@formo/analytics 1.38.0 → 1.38.2

package/dist/cjs/src/wagmi/WagmiEventHandler.js

@@ -75,6 +75,16 @@ var RESERVED_FIELDS = new Set([
     "transactionHash",
     "function_name",
     "function_args",
+    // Wallet attribution. Function args are spread AFTER the attribution
+    // properties, so an ABI input named `providerName` would silently
+    // relabel the wallet on every broadcast and receipt event. `rdns` is
+    // reserved with it even though THIS path (wagmi mutation attribution)
+    // emits only the name: elsewhere in the SDK - the EIP-1193 request path
+    // and connect events - `rdns` is the wallet-identity key, so an ABI
+    // input by that name would land in the same warehouse column as real
+    // wallet identities.
+    "providerName",
+    "rdns",
 ]);
 /**
  * Connections already announced to a destination during this page load.
@@ -242,8 +252,6 @@ var walletConnectPeerLookups = new WeakSet();
  * newest kicked one, so a slow resolution from a PREVIOUS session cannot
  * land after the current session's and overwrite it. */
 var walletConnectPeerLatest = new WeakMap();
-/** Connections whose provider already has the hybrid-capture wrapper. */
-var wagmiWrappedConnections = new WeakSet();
 /**
  * Pending transactions, shared per destination rather than per handler.
  *
@@ -428,6 +436,57 @@ var WagmiEventHandler = /** @class */ (function () {
          * Key format: `${queryHash}:${status}`
          */
         this.processedQueries = new Set();
+        /**
+         * Start resolving the wallet behind a WalletConnect connection.
+         *
+         * Fire-and-forget on purpose: emission paths are synchronous by design
+         * and must never wait (see the connect marker comment). Called at the
+         * START of the status/address flows rather than only at read time - the
+         * lookup is one microtask for an initialised connector, and the emission
+         * sits behind several awaits, so kicking early usually means even the
+         * FIRST connect names the real wallet. When the race is lost the event
+         * honestly says "WalletConnect" and every later event names the peer.
+         */
+        /**
+         * Install the request wrapper on the active connector's provider.
+         *
+         * This is what lets wagmi mode capture IMPERATIVE viem calls
+         * (walletClient.sendTransaction / .signMessage / .writeContract / raw
+         * request), which create no mutation and were silently lost. Hook-driven
+         * calls stay owned by the mutation handlers via the pending-mutation
+         * dedup. Fire-and-forget per connection; a provider that cannot be
+         * produced simply keeps mutation-only capture.
+         */
+        /**
+         * Connections THIS instance has wrapped. Deliberately per-instance, not
+         * module-level: a module-level guard let a rebuilt SDK instance skip
+         * re-wrapping, so ownership stayed with the torn-down instance and every
+         * capture died in its closed queue - and it also stopped a second
+         * write-key instance from ever registering. Re-wrapping is safe and
+         * cheap: the request tracker rebinds ownership of an intact wrapper.
+         */
+        /**
+         * Latest wrap attempt per connector. Every kick re-resolves
+         * getProvider() - a connector can hand out a REPLACEMENT provider after
+         * a reconnect, so a once-only guard would leave the new session's
+         * provider unwrapped forever. Re-wrapping is idempotent: the request
+         * tracker rebinds ownership of an intact wrapper. The epoch lets a slow
+         * resolution from a superseded kick (an earlier session, an earlier
+         * chain) be discarded instead of overwriting fresher state.
+         */
+        this.wrapEpochs = new WeakMap();
+        /** Consecutive automatic wrap retries per connector; see below. */
+        this.wrapRetryCounts = new WeakMap();
+        /** Pending retry timers, cancelled by cleanup(). */
+        this.wrapRetryTimers = new Set();
+        /**
+         * Bumped on every observed disconnect. Every wrap attempt captures it
+         * at kick time and its resolution stands down on a mismatch, so a
+         * disconnect invalidates ALL pending wraps at once - including ones
+         * whose getProvider() had not resolved yet, which no per-connector
+         * bookkeeping can reach because nothing has been recorded for them.
+         */
+        this.wrapSessionGeneration = 0;
         this.formo = formoAnalytics;
         this.wagmiConfig = wagmiConfig;
         this.queryClient = queryClient;
@@ -602,6 +661,10 @@ var WagmiEventHandler = /** @class */ (function () {
         var connectionUnsubscribe = this.wagmiConfig.subscribe(function (state) { var _a, _b; return "".concat((_a = state.current) !== null && _a !== void 0 ? _a : "", "|").concat((_b = _this.getConnectedAddress(state)) !== null && _b !== void 0 ? _b : ""); }, function (key, prevKey) {
             var _a = key.split("|"), address = _a[1];
             var _b = (prevKey !== null && prevKey !== void 0 ? prevKey : "|").split("|"), prevAddress = _b[1];
+            // A connector switch keeps status "connected", so the status
+            // subscription never re-wraps; the NEW active connection's provider
+            // must be instrumented from here or its imperative calls are lost.
+            _this.wrapActiveConnectorProvider(_this.getState());
             _this.handleActiveAddressChange(address || undefined, prevAddress || undefined);
         });
         this.unsubscribers.push(connectionUnsubscribe);
@@ -907,6 +970,19 @@ var WagmiEventHandler = /** @class */ (function () {
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
+                        if (status === "disconnected" || status === "reconnecting") {
+                            // The wrapped session is over - or, for "reconnecting", about to be
+                            // replaced without ever passing through "disconnected". This must
+                            // run for EVERY such transition, before the processing lock and
+                            // regardless of whether a wallet was being tracked, or a rapid
+                            // same-connector reconnect retains the old provider and the chain
+                            // callback writes the new session's chain onto it. The generation
+                            // bump invalidates every wrap still in flight from the ended
+                            // session, resolved or not. The "connected" that follows re-wraps.
+                            this.wrapSessionGeneration += 1;
+                            this.fallbackConnector = undefined;
+                            this.fallbackProvider = undefined;
+                        }
                         // Prevent concurrent processing
                         if (this.trackingState.isProcessing) {
                             // Dropped, not queued - but remember that a disconnect went past.
@@ -1443,10 +1519,31 @@ var WagmiEventHandler = /** @class */ (function () {
      */
     WagmiEventHandler.prototype.handleChainChange = function (chainId, prevChainId) {
         return __awaiter(this, void 0, void 0, function () {
-            var state, address, hadAddress, wasAnnounced, announcedNow;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var live, activeConnector, state, address, hadAddress, wasAnnounced, announcedNow;
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
+                        // Keep the fallback-wrapped provider's registry chain in step with the
+                        // store, so request-derived events are labelled correctly even when the
+                        // provider exposes no synchronous chainId. Only when the report is
+                        // about the connection that provider belongs to: after a connector
+                        // switch the store's chain describes the NEW connection, and writing it
+                        // to the old provider would mislabel that wallet's events.
+                        if (this.fallbackProvider !== undefined) {
+                            live = this.getState();
+                            activeConnector = live.current
+                                ? (_a = live.connections.get(live.current)) === null || _a === void 0 ? void 0 : _a.connector
+                                : undefined;
+                            if (activeConnector === this.fallbackConnector) {
+                                try {
+                                    (_c = (_b = this.formo)._rememberWagmiProviderChain) === null || _c === void 0 ? void 0 : _c.call(_b, this.fallbackProvider, chainId);
+                                }
+                                catch (_e) {
+                                    /* never let bookkeeping break the chain flow */
+                                }
+                            }
+                        }
                         if (chainId === prevChainId || chainId === undefined) {
                             return [2 /*return*/];
                         }
@@ -1492,7 +1589,7 @@ var WagmiEventHandler = /** @class */ (function () {
                         });
                         return [4 /*yield*/, this.applyChainForTrackedWallet(address, chainId)];
                     case 1:
-                        _a.sent();
+                        _d.sent();
                         return [2 /*return*/];
                 }
             });
@@ -2250,6 +2347,75 @@ var WagmiEventHandler = /** @class */ (function () {
         });
         return found;
     };
+    /**
+     * A specific connector's name and rdns, for the fallback-wrapped
+     * provider's request-derived events.
+     *
+     * The NAME is exactly what the hook path emits for that connector
+     * (`getConnectorName`: the live WalletConnect peer for a WalletConnect
+     * connector, the connector's own name otherwise), so a branded connector
+     * keeps its name on both paths and a session that changes wallets
+     * renames on both. The rdns is the connector's when wagmi knows it as
+     * ONE value (EIP-6963 discovered connectors carry theirs, some as a
+     * one-element list); a connector that matches several rdns values does
+     * not say which one this provider is, so nothing is passed and the
+     * registry keeps the sniffed one.
+     */
+    WagmiEventHandler.prototype.attributionForConnector = function (connector, state) {
+        var name = this.nameForConnector(connector, state);
+        if (!name) {
+            return undefined;
+        }
+        var raw = connector.rdns;
+        var rdns = typeof raw === "string" && raw.length > 0
+            ? raw
+            : Array.isArray(raw) && raw.length === 1 && typeof raw[0] === "string" && raw[0].length > 0
+                ? raw[0]
+                : undefined;
+        return __assign({ name: name }, (rdns && { rdns: rdns }));
+    };
+    /**
+     * Resolver handed to the registry at wrap time, read at each request
+     * start. BOUND to the connector whose `getProvider` resolved to the
+     * wrapped provider, not to whichever connector is current: an app can
+     * keep a wallet client over a previous connector's provider and issue a
+     * request through it after switching, and that request belongs to the
+     * wallet that handles it. The peer name is still read live. A provider
+     * SHARED by two connectors is re-bound when the new connector's
+     * resolution lands (one microtask for an injected connector); a request
+     * issued inside that gap keeps the previous label.
+     */
+    WagmiEventHandler.prototype.boundConnectorAttribution = function (connector) {
+        var _this = this;
+        return function () {
+            if (_this.disposed)
+                return undefined;
+            try {
+                return _this.attributionForConnector(connector, _this.getState());
+            }
+            catch (_a) {
+                return undefined;
+            }
+        };
+    };
+    /** `getConnectorName` for a SPECIFIC connector, current or not. */
+    WagmiEventHandler.prototype.nameForConnector = function (connector, state) {
+        var _a;
+        var cached = walletConnectPeerNames.get(connector);
+        if (cached) {
+            return cached;
+        }
+        var current = state.current
+            ? (_a = state.connections.get(state.current)) === null || _a === void 0 ? void 0 : _a.connector
+            : undefined;
+        if (current === connector) {
+            // Backstop kick, as in getConnectorName; only the current connection
+            // has a session to look up.
+            this.kickWalletConnectPeerLookup(state);
+        }
+        var name = connector.name;
+        return typeof name === "string" && name.length > 0 ? name : undefined;
+    };
     /**
      * Get the connector name from Wagmi state
      */
@@ -2271,30 +2437,10 @@ var WagmiEventHandler = /** @class */ (function () {
         this.kickWalletConnectPeerLookup(state);
         return connector.name;
     };
-    /**
-     * Start resolving the wallet behind a WalletConnect connection.
-     *
-     * Fire-and-forget on purpose: emission paths are synchronous by design
-     * and must never wait (see the connect marker comment). Called at the
-     * START of the status/address flows rather than only at read time - the
-     * lookup is one microtask for an initialised connector, and the emission
-     * sits behind several awaits, so kicking early usually means even the
-     * FIRST connect names the real wallet. When the race is lost the event
-     * honestly says "WalletConnect" and every later event names the peer.
-     */
-    /**
-     * Install the request wrapper on the active connector's provider.
-     *
-     * This is what lets wagmi mode capture IMPERATIVE viem calls
-     * (walletClient.sendTransaction / .signMessage / .writeContract / raw
-     * request), which create no mutation and were silently lost. Hook-driven
-     * calls stay owned by the mutation handlers via the pending-mutation
-     * dedup. Fire-and-forget per connection; a provider that cannot be
-     * produced simply keeps mutation-only capture.
-     */
-    WagmiEventHandler.prototype.wrapActiveConnectorProvider = function (state) {
+    WagmiEventHandler.prototype.wrapActiveConnectorProvider = function (state, isRetry) {
         var _this = this;
-        var _a, _b;
+        var _a, _b, _c;
+        if (isRetry === void 0) { isRetry = false; }
         // OPT-IN only. Wagmi mode's baseline never touches the signing
         // transport; instrumenting the provider is an explicit integrator
         // decision (options.wagmi.eip1193Fallback), made auditable in
@@ -2303,25 +2449,124 @@ var WagmiEventHandler = /** @class */ (function () {
         if (!optedIn) {
             return;
         }
+        if (state.status !== "connected") {
+            // Status kicks run for every transition; only a connected snapshot
+            // describes a session worth wrapping.
+            return;
+        }
         var connection = state.current
             ? state.connections.get(state.current)
             : undefined;
         var connector = connection === null || connection === void 0 ? void 0 : connection.connector;
-        if (!connection ||
-            typeof (connector === null || connector === void 0 ? void 0 : connector.getProvider) !== "function" ||
-            wagmiWrappedConnections.has(connection)) {
+        if (!connection || typeof (connector === null || connector === void 0 ? void 0 : connector.getProvider) !== "function") {
             return;
         }
-        wagmiWrappedConnections.add(connection);
-        connector
-            .getProvider()
+        var epoch = ((_c = this.wrapEpochs.get(connector)) !== null && _c !== void 0 ? _c : 0) + 1;
+        this.wrapEpochs.set(connector, epoch);
+        var session = this.wrapSessionGeneration;
+        // A store-driven kick resets the retry budget; automatic retries
+        // (below) spend it.
+        if (!isRetry) {
+            this.wrapRetryCounts.delete(connector);
+        }
+        // When the NEWEST attempt fails, older in-flight resolutions have
+        // been epoch-discarded (they may describe an earlier session) and
+        // nothing else would wrap the provider until the next store update.
+        // Recover by re-kicking fresh with live state, bounded so a
+        // persistently failing connector cannot loop: after the budget is
+        // spent, recovery waits for a real store update, which resets it.
+        var retryAfterFailure = function () {
+            var _a;
+            if (_this.disposed)
+                return;
+            if (_this.wrapEpochs.get(connector) !== epoch) {
+                // Superseded: the newer attempt owns recovery.
+                return;
+            }
+            var failures = ((_a = _this.wrapRetryCounts.get(connector)) !== null && _a !== void 0 ? _a : 0) + 1;
+            _this.wrapRetryCounts.set(connector, failures);
+            if (failures > 3)
+                return;
+            var timer = setTimeout(function () {
+                var _a;
+                _this.wrapRetryTimers.delete(timer);
+                if (_this.disposed)
+                    return;
+                // Re-kick only while THIS connector is still the active one and
+                // no newer attempt superseded this one. A retry for a connector
+                // the user has left must not fire at the current connector: with
+                // the retry flag it would skip the budget reset and, worse, its
+                // fresh epoch would discard the current connector's own in-flight
+                // resolution.
+                var live = _this.getState();
+                var stillCurrent = live.current !== undefined &&
+                    ((_a = live.connections.get(live.current)) === null || _a === void 0 ? void 0 : _a.connector) === connector;
+                if (stillCurrent && _this.wrapEpochs.get(connector) === epoch) {
+                    _this.wrapActiveConnectorProvider(live, true);
+                }
+            }, 25 * failures);
+            _this.wrapRetryTimers.add(timer);
+        };
+        var resolution;
+        try {
+            resolution = connector.getProvider();
+        }
+        catch (_d) {
+            // A synchronous throw must not escape into the subscription
+            // callback: address-change handling runs after this kick and a
+            // propagated throw would silently skip it.
+            retryAfterFailure();
+            return;
+        }
+        resolution
             .then(function (provider) {
-            var _a, _b;
-            (_b = (_a = _this.formo)._wrapWagmiProvider) === null || _b === void 0 ? void 0 : _b.call(_a, provider);
+            var _a, _b, _c, _d;
+            if (_this.wrapEpochs.get(connector) !== epoch) {
+                // A newer kick is in flight or already resolved; this answer may
+                // describe an earlier session. Let the newest one win.
+                return;
+            }
+            // The fallback installs only the request wrapper, so a provider
+            // without a synchronous chainId property would never teach the
+            // registry its chain and its events would carry chain 0. The wagmi
+            // store knows; feed it here and on every later chain change. Read
+            // the chain from LIVE state, not from a snapshot taken before this
+            // asynchronous resolution: a switch that lands while getProvider is
+            // in flight fires handleChainChange before fallbackProvider exists,
+            // so a pre-resolution snapshot would stick as the recorded chain.
+            // Activity is judged by CONNECTOR identity: wagmi replaces the
+            // connection record itself on every account or chain update.
+            var live = _this.getState();
+            // A wrap only describes a CONNECTED session. Status changes kick
+            // this path for every transition, and a resolution landing while
+            // disconnected would re-point the fallback pair at a provider
+            // whose session is over.
+            var stillActive = !_this.disposed &&
+                _this.wrapSessionGeneration === session &&
+                live.status === "connected" &&
+                live.current !== undefined &&
+                ((_a = live.connections.get(live.current)) === null || _a === void 0 ? void 0 : _a.connector) === connector;
+            if (!stillActive) {
+                // The user moved on while getProvider was in flight. Wrapping
+                // now would instrument a provider whose chain nobody feeds -
+                // its requests would report chain 0. Switching back re-kicks.
+                return;
+            }
+            var chainId = (_b = _this.getActiveConnectionChainId(live)) !== null && _b !== void 0 ? _b : live.chainId;
+            var wrapped = (_d = (_c = _this.formo)._wrapWagmiProvider) === null || _d === void 0 ? void 0 : _d.call(_c, provider, typeof chainId === "number" ? chainId : undefined, _this.boundConnectorAttribution(connector));
+            if (wrapped !== true) {
+                // The provider was refused (invalid shape, frozen provider,
+                // torn-down SDK).
+                retryAfterFailure();
+                return;
+            }
+            _this.wrapRetryCounts.delete(connector);
+            _this.fallbackConnector = connector;
+            _this.fallbackProvider = provider;
         })
             .catch(function () {
-            // Mutation-only capture remains; retry on the next connection.
-            wagmiWrappedConnections.delete(connection);
+            // Mutation-only capture remains.
+            retryAfterFailure();
         });
     };
     WagmiEventHandler.prototype.kickWalletConnectPeerLookup = function (state) {
@@ -2411,6 +2656,8 @@ var WagmiEventHandler = /** @class */ (function () {
      * Clean up all subscriptions
      */
     WagmiEventHandler.prototype.cleanup = function () {
+        this.wrapRetryTimers.forEach(function (t) { return clearTimeout(t); });
+        this.wrapRetryTimers.clear();
         logger_1.logger.debug("WagmiEventHandler: Cleaning up subscriptions");
         if (!this.disposed) {
             this.disposed = true;

package/dist/cjs/src/wagmi/types.d.ts

@@ -31,6 +31,12 @@ export interface WagmiConnector {
     name: string;
     type: string;
     uid: string;
+    /**
+     * Any connector implementation may expose an rdns; EIP-6963 discovered
+     * connectors are one source. A connector matching several rdns values
+     * lists them all.
+     */
+    rdns?: string | readonly string[];
 }
 /**
  * Wagmi config interface

package/dist/cjs/src/wagmi/utils.js

@@ -192,7 +192,15 @@ function buildSafeFunctionArgs(functionArgs, reservedFields) {
     var result = {};
     for (var _i = 0, _a = Object.entries(functionArgs); _i < _a.length; _i++) {
         var _b = _a[_i], key = _b[0], val = _b[1];
-        var safeKey = reservedFields.has(key) ? "arg_".concat(key) : key;
+        // A prefixed key must not land on another argument's own name: an ABI
+        // with both `to` and `arg_to` would otherwise keep only one of them,
+        // whichever came later. Keep prefixing until the name is free.
+        var safeKey = key;
+        if (reservedFields.has(key)) {
+            do {
+                safeKey = "arg_".concat(safeKey);
+            } while (safeKey in functionArgs);
+        }
         result[safeKey] = val;
         // If the value is a nested object (struct), flatten it
         // Skip flattened keys that would overwrite existing top-level args

package/dist/esm/src/FormoAnalytics.d.ts

@@ -402,9 +402,9 @@ export declare class FormoAnalytics implements IFormoAnalytics {
      *
      * With several live SDK instances (multi write-key pages) registering
      * the SAME provider, request-derived events (signatures, transactions)
-     * go to the most recently registered live instance - the same
-     * single-observer semantics discovery has always had for the request
-     * wrapper. Lifecycle events (connect, chain, disconnect) reach every
+     * go to the most recently CREATED live instance, regardless of the
+     * order registrations happen to land in - the same single-observer
+     * semantics discovery has always had for the request wrapper. Lifecycle events (connect, chain, disconnect) reach every
      * instance. Fanning request observations out to all instances is a
      * separate feature.
      *
@@ -428,8 +428,19 @@ export declare class FormoAnalytics implements IFormoAnalytics {
      * gap. Lifecycle (connect/chain/disconnect) stays store-driven: only the
      * request wrapper installs here. Double counting is prevented in the
      * wrapper via `shouldSkipRequestCapture`.
+     *
+     * `attribution` resolves, live, the name and rdns of the connector this
+     * provider was wrapped for. Request-derived events are named from the
+     * registry, which for an unannounced provider falls back to flag
+     * sniffing; recording the connector's resolver here keeps them in
+     * agreement with the hook-driven events for that connector.
      */
-    _wrapWagmiProvider(provider: EIP1193Provider): void;
+    _wrapWagmiProvider(provider: EIP1193Provider, chainId?: number, attribution?: () => {
+        name: string;
+        rdns?: string;
+    } | undefined): boolean;
+    /** INTERNAL. Chain updates for the fallback-wrapped provider. */
+    _rememberWagmiProviderChain(provider: EIP1193Provider, chainId: number | undefined): void;
     registerProvider(provider: EIP1193Provider, info?: {
         name?: string;
         rdns?: string;

package/dist/esm/src/FormoAnalytics.js

@@ -1015,6 +1015,9 @@ var FormoAnalytics = /** @class */ (function () {
         // Drop anything already buffered so a pending timer/pagehide flush
         // cannot ship events after consent withdrawal.
         this.eventManager.clear();
+        // Identity is purged below; registered sessions must be re-learned
+        // on opt-in, and nothing else would retry an already-adopted one.
+        this.evmEvents.markRegisteredAdoptionsPending();
         this.reset();
         logger.info("Successfully opted out of tracking");
     };
@@ -1334,9 +1337,9 @@ var FormoAnalytics = /** @class */ (function () {
      *
      * With several live SDK instances (multi write-key pages) registering
      * the SAME provider, request-derived events (signatures, transactions)
-     * go to the most recently registered live instance - the same
-     * single-observer semantics discovery has always had for the request
-     * wrapper. Lifecycle events (connect, chain, disconnect) reach every
+     * go to the most recently CREATED live instance, regardless of the
+     * order registrations happen to land in - the same single-observer
+     * semantics discovery has always had for the request wrapper. Lifecycle events (connect, chain, disconnect) reach every
      * instance. Fanning request observations out to all instances is a
      * separate feature.
      *
@@ -1360,15 +1363,43 @@ var FormoAnalytics = /** @class */ (function () {
      * gap. Lifecycle (connect/chain/disconnect) stays store-driven: only the
      * request wrapper installs here. Double counting is prevented in the
      * wrapper via `shouldSkipRequestCapture`.
+     *
+     * `attribution` resolves, live, the name and rdns of the connector this
+     * provider was wrapped for. Request-derived events are named from the
+     * registry, which for an unannounced provider falls back to flag
+     * sniffing; recording the connector's resolver here keeps them in
+     * agreement with the hook-driven events for that connector.
      */
-    FormoAnalytics.prototype._wrapWagmiProvider = function (provider) {
+    FormoAnalytics.prototype._wrapWagmiProvider = function (provider, chainId, attribution) {
         if (this.isCleanedUp || !isValidProvider(provider))
-            return;
+            return false;
         try {
-            this.evmRequests.registerRequestListeners(provider);
+            // The tracker reports refusals (frozen provider, unrebindable
+            // wrapper) by returning false rather than throwing; treat those as
+            // failures too so the caller can retry later.
+            if (!this.evmRequests.registerRequestListeners(provider)) {
+                return false;
+            }
+            this.evm.rememberAttribution(provider, attribution);
+            if (chainId !== undefined) {
+                this.evm.rememberChain(provider, chainId);
+            }
+            return true;
         }
         catch (e) {
             logger.warn("Failed to wrap wagmi provider for hybrid capture", e);
+            return false;
+        }
+    };
+    /** INTERNAL. Chain updates for the fallback-wrapped provider. */
+    FormoAnalytics.prototype._rememberWagmiProviderChain = function (provider, chainId) {
+        if (this.isCleanedUp)
+            return;
+        try {
+            this.evm.rememberChain(provider, chainId);
+        }
+        catch (_a) {
+            /* bookkeeping only */
         }
     };
     FormoAnalytics.prototype.registerProvider = function (provider, info) {

package/dist/esm/src/FormoAnalyticsProvider.d.ts

@@ -7,6 +7,14 @@ export interface FormoAnalyticsProviderProps {
     children: ReactNode;
 }
 export declare const FormoAnalyticsContext: import("react").Context<IFormoAnalytics>;
+/**
+ * A stable key over the serializable parts of Options. The provider effect
+ * re-initialises the SDK when this key changes; anything that alters SDK
+ * behaviour must be represented here, or a runtime change to it is silently
+ * ignored. Complex objects are tracked by presence, plus the flags that
+ * change what the SDK does with them.
+ */
+export declare const computeOptionsKey: (options?: Options) => string;
 export declare const FormoAnalyticsProvider: FC<FormoAnalyticsProviderProps>;
 export declare const useFormo: () => IFormoAnalytics;
 //# sourceMappingURL=FormoAnalyticsProvider.d.ts.map

package/dist/esm/src/FormoAnalyticsProvider.js

@@ -69,6 +69,44 @@ var defaultContext = {
     hasOptedOutTracking: function () { return false; },
 };
 export var FormoAnalyticsContext = createContext(defaultContext);
+/**
+ * A stable key over the serializable parts of Options. The provider effect
+ * re-initialises the SDK when this key changes; anything that alters SDK
+ * behaviour must be represented here, or a runtime change to it is silently
+ * ignored. Complex objects are tracked by presence, plus the flags that
+ * change what the SDK does with them.
+ */
+export var computeOptionsKey = function (options) {
+    var _a;
+    if (!options)
+        return 'undefined';
+    var serializableOptions = {
+        tracking: options.tracking,
+        autocapture: options.autocapture,
+        crossSubdomainCookies: options.crossSubdomainCookies,
+        apiHost: options.apiHost,
+        flushAt: options.flushAt,
+        flushInterval: options.flushInterval,
+        retryCount: options.retryCount,
+        maxQueueSize: options.maxQueueSize,
+        logger: options.logger,
+        referral: options.referral,
+        evm: options.evm,
+        // For complex objects, just track their presence, not their content
+        hasProvider: !!options.provider,
+        hasWagmi: !!options.wagmi,
+        wagmiEip1193Fallback: !!((_a = options.wagmi) === null || _a === void 0 ? void 0 : _a.eip1193Fallback),
+        hasReady: !!options.ready,
+    };
+    try {
+        return JSON.stringify(serializableOptions);
+    }
+    catch (error) {
+        // Fallback to timestamp if serialization fails
+        logger.warn('Failed to serialize options, using timestamp', error);
+        return Date.now().toString();
+    }
+};
 export var FormoAnalyticsProvider = function (props) {
     var writeKey = props.writeKey, _a = props.disabled, disabled = _a === void 0 ? false : _a, children = props.children;
     // Keep the app running without analytics if no Write Key is provided or disabled
@@ -87,37 +125,7 @@ var InitializedAnalytics = function (_a) {
     var _b = useState(defaultContext), sdk = _b[0], setSdk = _b[1];
     var sdkRef = useRef(defaultContext);
     initStorageManager(writeKey);
-    // Create a stable key from options that ignores complex objects and functions
-    // We only care about serializable config values that would affect SDK behavior
-    var optionsKey = useMemo(function () {
-        if (!options)
-            return 'undefined';
-        // Extract only the serializable parts of options
-        var serializableOptions = {
-            tracking: options.tracking,
-            autocapture: options.autocapture,
-            crossSubdomainCookies: options.crossSubdomainCookies,
-            apiHost: options.apiHost,
-            flushAt: options.flushAt,
-            flushInterval: options.flushInterval,
-            retryCount: options.retryCount,
-            maxQueueSize: options.maxQueueSize,
-            logger: options.logger,
-            referral: options.referral,
-            // For complex objects, just track their presence, not their content
-            hasProvider: !!options.provider,
-            hasWagmi: !!options.wagmi,
-            hasReady: !!options.ready,
-        };
-        try {
-            return JSON.stringify(serializableOptions);
-        }
-        catch (error) {
-            // Fallback to timestamp if serialization fails
-            logger.warn('Failed to serialize options, using timestamp', error);
-            return Date.now().toString();
-        }
-    }, [options]);
+    var optionsKey = useMemo(function () { return computeOptionsKey(options); }, [options]);
     useEffect(function () {
         var isCleanedUp = false;
         var initialize = function () { return __awaiter(void 0, void 0, void 0, function () {