@formo/analytics 1.35.1 → 1.35.2

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

@@ -70,6 +70,259 @@ var RESERVED_FIELDS = new Set([
     "function_name",
     "function_args",
 ]);
+/**
+ * Connections already announced to a destination during this page load.
+ *
+ * Deliberately module scoped rather than per handler or per FormoAnalytics
+ * instance. The duplicate this prevents comes from the SDK instance itself
+ * being rebuilt - a provider remount, an options change, HMR - while the
+ * wallet never disconnected, and per-instance state cannot see that.
+ *
+ * A real disconnect clears the entry, so a genuine reconnect within the same
+ * page load still emits. A new page load starts with a fresh module scope.
+ */
+var announcedConnections = new Set();
+/**
+ * Connections announced, keyed by the wagmi connection OBJECT.
+ *
+ * Wagmi builds a fresh connection object on every `connect()`, and replaces it
+ * whenever anything about the connection changes. So finding the SAME object
+ * still in the store is proof that nothing happened in between - no
+ * disconnect, no reconnect - and the marker can be trusted with no time limit
+ * at all. That covers the case the grace period alone gets wrong: an SDK
+ * unmounted for a long time while the wallet simply stayed connected.
+ *
+ * The address-keyed set above remains the fallback for the genuinely
+ * ambiguous case, where the object was replaced but a chain switch and a
+ * reconnect are indistinguishable after the fact.
+ *
+ * Weak, so a dead connection is collected rather than pinned.
+ */
+var announcedByConnection = new WeakMap();
+/**
+ * Keyed by write key as well as address: two SDK instances for different write
+ * keys are separate analytics destinations with separate queues, so the second
+ * must still receive its own connect for the same wallet.
+ *
+ * The connector uid is NOT part of the key. Wagmi keeps that uid stable across
+ * a disconnect and reconnect through the same connector, so including it never
+ * distinguished one connection occurrence from the next. The observation
+ * window below is what makes a reconnect emit again.
+ */
+var announceKey = function (writeKey, address) {
+    return "".concat(writeKey, ":").concat(address.toLowerCase());
+};
+/**
+ * How long the markers stay trustworthy after the last handler goes away.
+ *
+ * A marker only means "already announced" while the SDK is actually watching
+ * wagmi. With no handler mounted nothing observes a disconnect, so a wallet
+ * that disconnects and reconnects in that window would otherwise look
+ * unchanged and its genuine connect would be swallowed for the rest of the
+ * page load.
+ *
+ * Rebuilding the SDK tears the old handler down and builds a new one, and
+ * `FormoAnalytics.init()` is async, so the gap is real but short. This grace
+ * period spans a rebuild and little else: markers survive it, and a longer
+ * unmount discards them so the next connect is treated as new.
+ */
+export var MARKER_GRACE_MS = 3000;
+/**
+ * Liveness is tracked PER WRITE KEY, because markers are.
+ *
+ * A global count would let one destination keep another's markers alive: with
+ * destination B still mounted, A's would never expire, so a wallet that
+ * disconnected and reconnected while A was unmounted would have its genuine
+ * connect suppressed when A came back.
+ */
+var liveHandlers = new Map();
+var markerExpiry = new Map();
+/**
+ * @param adoptsLiveConnection whether the arriving handler actually found the
+ *   announced connection still in place. Only then may it cancel the expiry:
+ *   a replacement that mounts over a DISCONNECTED store has observed nothing,
+ *   so cancelling would strand the markers for the rest of the page load and
+ *   suppress a genuine connect hours later.
+ */
+function retainMarkers(writeKey, adoptsLiveConnection) {
+    var _a;
+    liveHandlers.set(writeKey, ((_a = liveHandlers.get(writeKey)) !== null && _a !== void 0 ? _a : 0) + 1);
+    if (!adoptsLiveConnection)
+        return;
+    var pending = markerExpiry.get(writeKey);
+    if (pending) {
+        clearTimeout(pending);
+        markerExpiry.delete(writeKey);
+    }
+}
+function releaseMarkers(writeKey) {
+    var _a, _b, _c;
+    var remaining = Math.max(0, ((_a = liveHandlers.get(writeKey)) !== null && _a !== void 0 ? _a : 0) - 1);
+    liveHandlers.set(writeKey, remaining);
+    var wasLast = remaining === 0;
+    if (remaining > 0 || markerExpiry.has(writeKey))
+        return wasLast;
+    var timer = setTimeout(function () {
+        markerExpiry.delete(writeKey);
+        var prefix = "".concat(writeKey, ":");
+        announcedConnections.forEach(function (key) {
+            if (key.startsWith(prefix))
+                announcedConnections.delete(key);
+        });
+    }, MARKER_GRACE_MS);
+    // Never hold a Node process (or a test run) open for this.
+    (_c = (_b = timer).unref) === null || _c === void 0 ? void 0 : _c.call(_b);
+    markerExpiry.set(writeKey, timer);
+    return wasLast;
+}
+/**
+ * The one handler allowed to EMIT for a given destination.
+ *
+ * Two handlers can be alive at once over the same wagmi config and write key:
+ * Strict Mode, HMR, or an options change whose replacement mounts before the
+ * old one is torn down - which the marker grace period explicitly supports.
+ * Non-owners still track state, so whichever survives cleanup is already
+ * correct and takes over immediately; they simply do not emit.
+ */
+var emittingOwners = new Map();
+/** Stable per-config id, so the owner key can span SDK instances. */
+var configIds = new WeakMap();
+var nextConfigId = 0;
+var ownerKey = function (writeKey, config) {
+    var id = configIds.get(config);
+    if (!id) {
+        id = "cfg".concat((nextConfigId += 1));
+        configIds.set(config, id);
+    }
+    return "".concat(writeKey, ":").concat(id);
+};
+/**
+ * Pending transactions, shared per destination rather than per handler.
+ *
+ * A broadcast observed by handler A, followed by a replacement B taking over
+ * before the receipt arrives, otherwise loses the confirmation entirely: A no
+ * longer emits because it is not the owner, and B has no record of the
+ * broadcast to match the receipt against.
+ */
+var pendingTransactionsByDestination = new Map();
+/**
+ * Pending records outlive a rebuild by the same grace period as the markers.
+ * The ordinary rebuild is cleanup THEN remount, so dropping them the instant
+ * the last handler goes would lose the receipt for anything broadcast just
+ * before teardown.
+ */
+var pendingTransactionExpiry = new Map();
+function schedulePendingTransactionExpiry(key) {
+    var _a, _b;
+    if (pendingTransactionExpiry.has(key))
+        return;
+    var timer = setTimeout(function () {
+        pendingTransactionExpiry.delete(key);
+        pendingTransactionsByDestination.delete(key);
+    }, MARKER_GRACE_MS);
+    (_b = (_a = timer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    pendingTransactionExpiry.set(key, timer);
+}
+function cancelPendingTransactionExpiry(key) {
+    var timer = pendingTransactionExpiry.get(key);
+    if (!timer)
+        return;
+    clearTimeout(timer);
+    pendingTransactionExpiry.delete(key);
+}
+/**
+ * Has this destination already announced this wallet on this very connection?
+ *
+ * `exact` means the wagmi connection object is unchanged since the
+ * announcement, which is proof nothing happened in between and holds however
+ * long the SDK was away. `recent` means the object was replaced but the
+ * announcement is still inside the observation window.
+ */
+function announcementState(key, connection) {
+    var _a;
+    if (connection && ((_a = announcedByConnection.get(connection)) === null || _a === void 0 ? void 0 : _a.has(key))) {
+        return "exact";
+    }
+    return announcedConnections.has(key) ? "recent" : "none";
+}
+/**
+ * Undo an announcement claim whose emission failed.
+ *
+ * `markAnnounced()` is called before the event is handed to FormoAnalytics,
+ * so the claim exists while the emission is in flight and a concurrent
+ * handler cannot double-report. If that emission then fails, nothing was
+ * reported - and leaving the claim standing means a retry or a replacement
+ * handler treats the wallet as done, losing its connect for the rest of the
+ * page load even after the queue recovers.
+ */
+function releaseAnnouncement(key, connection) {
+    var _a;
+    announcedConnections.delete(key);
+    if (connection)
+        (_a = announcedByConnection.get(connection)) === null || _a === void 0 ? void 0 : _a.delete(key);
+}
+/**
+ * Record a connection as announced.
+ *
+ * Deliberately unbounded. Entries are removed when the wallet disconnects,
+ * and pruned against the live connections whenever a handler mounts, so the
+ * set can only hold wallets that are actually connected right now. An earlier
+ * revision carried a size cap as a backstop; with both of those in place it
+ * was unreachable, and the test covering it passed with the cap removed.
+ */
+function markAnnounced(key, connection) {
+    var _a;
+    if (connection) {
+        var keys = (_a = announcedByConnection.get(connection)) !== null && _a !== void 0 ? _a : new Set();
+        keys.add(key);
+        announcedByConnection.set(connection, keys);
+    }
+    announcedConnections.add(key);
+}
+/** Test hook. Real page loads reset this naturally. */
+export function __resetSeededWallet() {
+    emittingOwners.clear();
+    pendingTransactionExpiry.forEach(function (t) { return clearTimeout(t); });
+    pendingTransactionExpiry.clear();
+    pendingTransactionsByDestination.clear();
+    announcedConnections.clear();
+    liveHandlers.clear();
+    markerExpiry.forEach(function (timer) { return clearTimeout(timer); });
+    markerExpiry.clear();
+}
+/**
+ * wagmi accepts an `account` as either a bare address or a viem Account
+ * object. Normalise both to an address, or undefined when absent.
+ */
+/**
+ * Coerce a wagmi/viem chain id to a number.
+ *
+ * An EIP-712 domain carries whatever the caller put in it, and viem accepts a
+ * hex string or a bigint there as well as a number. Passing those straight
+ * through would put a non-number in the event payload and defeat the numeric
+ * comparison in `tracking.excludeChains`.
+ */
+function normalizeChainId(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : undefined;
+    if (typeof value === "bigint")
+        return Number(value);
+    if (typeof value === "string" && value.trim() !== "") {
+        var parsed = value.startsWith("0x") ? Number(value) : Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+function resolveAccountAddress(account) {
+    if (typeof account === "string")
+        return account;
+    if (account && typeof account === "object") {
+        var address = account.address;
+        if (typeof address === "string")
+            return address;
+    }
+    return undefined;
+}
 /**
  * Clean up old entries from a Set to prevent memory leaks.
  * Removes oldest entries when size exceeds maxSize.
@@ -94,6 +347,26 @@ var WagmiEventHandler = /** @class */ (function () {
         this.trackingState = {
             isProcessing: false,
         };
+        /**
+         * Set by `cleanup()`. Every deferred emission checks it, so a handler that
+         * has been torn down cannot push an event into a queue the replacement SDK
+         * instance no longer owns.
+         */
+        this.disposed = false;
+        /** Reentrancy guard for `reconcileWithLiveState()`. */
+        this.reconciling = false;
+        /**
+         * Ticket for each active-connection transition. Emissions are awaited, and
+         * wagmi can move again in that window; a continuation whose ticket is no
+         * longer current must not write stale state over the newer one.
+         */
+        this.transitionGeneration = 0;
+        /**
+         * A `disconnected` status that arrived while the lock was held. Final-state
+         * reconciliation cannot see a disconnect/reconnect cycle that completed
+         * inside that window, so this records that one happened.
+         */
+        this.missedDisconnect = false;
         /**
          * Track processed mutation states to prevent duplicate event emissions
          * Key format: `${mutationId}:${status}`
@@ -104,17 +377,35 @@ var WagmiEventHandler = /** @class */ (function () {
          * Key format: `${queryHash}:${status}`
          */
         this.processedQueries = new Set();
-        /**
-         * Store transaction details from BROADCASTED events for use in CONFIRMED/REVERTED
-         * Key: transactionHash, Value: transaction details including the original sender address
-         */
-        this.pendingTransactions = new Map();
         this.formo = formoAnalytics;
         this.wagmiConfig = wagmiConfig;
         this.queryClient = queryClient;
         logger.info("WagmiEventHandler: Initializing Wagmi integration");
+        // Keep the page-load markers alive across an SDK rebuild. Must run before
+        // the seed, so a handler created moments after its predecessor was torn
+        // down still sees what that predecessor announced.
+        // Only a handler that finds an ANNOUNCED wallet still connected may hold
+        // the markers open. Mounting over a disconnected store has observed
+        // nothing; mounting over a DIFFERENT wallet is worse still - it would
+        // preserve the previous wallet's marker and suppress its genuine
+        // reconnect for the rest of the page load. Markers for wallets no longer
+        // in `state.connections` are dropped outright.
+        var livesOverConnection = this.pruneMarkersForLostWallets();
+        retainMarkers(this.formo.writeKey, livesOverConnection);
+        // Claim the right to emit for this destination. The NEWEST handler always
+        // wins, deliberately: an app that rebuilds without calling `cleanup()`
+        // leaks the old handler, and letting that stale one keep ownership would
+        // silence the live one for the rest of the page load - far worse than the
+        // duplicate events this is here to prevent.
+        this.ownerKey = ownerKey(this.formo.writeKey, wagmiConfig);
+        emittingOwners.set(this.ownerKey, this);
+        // A remount for this destination cancels the pending-record expiry the
+        // previous handler started.
+        cancelPendingTransactionExpiry(this.ownerKey);
         // Set up connection/disconnection/chain listeners
         this.setupConnectionListeners();
+        // Adopt a wallet that connected before this handler existed.
+        this.seedFromCurrentState();
         // Set up mutation and query tracking if QueryClient is provided
         if (this.queryClient) {
             this.setupMutationTracking();
@@ -124,6 +415,88 @@ var WagmiEventHandler = /** @class */ (function () {
             logger.warn("WagmiEventHandler: QueryClient not provided, signature and transaction events will not be tracked");
         }
     }
+    /**
+     * Drop markers for wallets wagmi no longer holds, and report whether any
+     * announced wallet is still connected.
+     *
+     * Called when a handler mounts. Cancelling the expiry timer on the strength
+     * of "some connection exists" let a marker for a wallet that had since
+     * disconnected survive indefinitely, suppressing its genuine reconnect.
+     */
+    WagmiEventHandler.prototype.pruneMarkersForLostWallets = function () {
+        var _this = this;
+        var state;
+        try {
+            state = this.getState();
+        }
+        catch (_a) {
+            return false;
+        }
+        var prefix = "".concat(this.formo.writeKey, ":");
+        var live = new Set();
+        state.connections.forEach(function (connection) {
+            connection.accounts.forEach(function (a) {
+                return live.add(announceKey(_this.formo.writeKey, a));
+            });
+        });
+        var announcedStillConnected = false;
+        announcedConnections.forEach(function (key) {
+            if (!key.startsWith(prefix))
+                return;
+            if (live.has(key))
+                announcedStillConnected = true;
+            else
+                announcedConnections.delete(key);
+        });
+        return announcedStillConnected;
+    };
+    Object.defineProperty(WagmiEventHandler.prototype, "isEmittingOwner", {
+        /**
+         * Whether this handler is the one allowed to emit for its destination.
+         *
+         * A handler that lost the race still tracks state, so it is ready to take
+         * over the moment the owner goes away; it just does not emit.
+         */
+        get: function () {
+            if (!this.ownerKey)
+                return true;
+            var owner = emittingOwners.get(this.ownerKey);
+            if (!owner) {
+                // Nobody holds it - the previous owner was torn down. Claim it.
+                emittingOwners.set(this.ownerKey, this);
+                return true;
+            }
+            return owner === this;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WagmiEventHandler.prototype, "pendingTransactions", {
+        /**
+         * Store transaction details from BROADCASTED events for use in CONFIRMED/REVERTED
+         * Key: transactionHash, Value: transaction details including the original sender address
+         */
+        /**
+         * Shared per destination, not per handler.
+         *
+         * A broadcast observed by handler A, followed by a replacement B taking
+         * over before the receipt arrives, used to lose the confirmation entirely:
+         * A no longer emits because it is not the owner, and B had no record of the
+         * broadcast to match the receipt against.
+         */
+        get: function () {
+            var _a;
+            var key = (_a = this.ownerKey) !== null && _a !== void 0 ? _a : "";
+            var map = pendingTransactionsByDestination.get(key);
+            if (!map) {
+                map = new Map();
+                pendingTransactionsByDestination.set(key, map);
+            }
+            return map;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Set up listeners for wallet connection, disconnection, and chain changes
      */
@@ -135,83 +508,832 @@ var WagmiEventHandler = /** @class */ (function () {
             _this.handleStatusChange(status, prevStatus);
         });
         this.unsubscribers.push(statusUnsubscribe);
-        // Subscribe to chain ID changes
-        var chainIdUnsubscribe = this.wagmiConfig.subscribe(function (state) { return state.chainId; }, function (chainId, prevChainId) {
+        // Subscribe to chain ID changes.
+        //
+        // Selects the ACTIVE CONNECTION's chain, with the global as a fallback -
+        // the same rule every read site here uses. Selecting only `state.chainId`
+        // meant that with several connections, or with `syncConnectedChain: false`,
+        // the active connection could move to a new chain while the global stayed
+        // put: no callback ran, and both the tracked chain and Formo's central
+        // chain silently went stale for every later event.
+        var chainIdUnsubscribe = this.wagmiConfig.subscribe(function (state) { var _a; return (_a = _this.getActiveConnectionChainId(state)) !== null && _a !== void 0 ? _a : state.chainId; }, function (chainId, prevChainId) {
             _this.handleChainChange(chainId, prevChainId);
         });
         this.unsubscribers.push(chainIdUnsubscribe);
+        // Subscribe to the active connection as a whole: its connector id AND its
+        // address, as one string.
+        //
+        // `state.status` is a single global value, so it stays "connected" when a
+        // user switches account inside an already-connected wallet. Without this
+        // the switch is invisible: no event, and the tracked address goes stale
+        // and mis-attributes every later signature and transaction.
+        //
+        // The connector id has to be in the key too. Selecting the address alone
+        // missed the case where two connectors hold the SAME account - MetaMask
+        // and Rabby over one hardware wallet, say - and the current one
+        // disconnects: wagmi falls back to the other, the address is unchanged, so
+        // nothing fired and the disconnect was lost for good.
+        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];
+            _this.handleActiveAddressChange(address || undefined, prevAddress || undefined);
+        });
+        this.unsubscribers.push(connectionUnsubscribe);
         logger.info("WagmiEventHandler: Connection listeners set up successfully");
     };
+    /**
+     * Adopt a connection that already existed when this handler was created.
+     *
+     * `config.subscribe` reports *changes* only, so a wallet restored by wagmi's
+     * mount-time `reconnect()` is invisible to a handler built afterwards. That
+     * is the normal case whenever the host app loads the SDK lazily (dynamic
+     * import, `requestIdleCallback`) and can also happen on a plain mount, since
+     * `FormoAnalytics.init()` and wagmi's reconnect are both async and race.
+     *
+     * Without this seed the whole session is lost: no connect event, and
+     * `lastAddress` stays undefined so the signature and transaction handlers
+     * drop their events too, and the eventual disconnect carries neither address
+     * nor chain id.
+     *
+     * `subscribe(..., { fireImmediately: true })` is not a substitute. It reports
+     * the current value with no distinct previous value, so the connect branch's
+     * `prevStatus !== "connected"` test never passes, and wagmi v3 does not
+     * honour the option at all.
+     *
+     * Deliberately synchronous, and deliberately does NOT take the
+     * `isProcessing` lock. Everything that mutates tracking state runs before
+     * any await, so no status change can interleave with it. Holding the lock
+     * across the `connect()` emission instead would make `handleStatusChange()`
+     * drop - not defer - a disconnect or wallet switch that lands in that
+     * window, which is exactly when a lazily loaded SDK is racing app activity.
+     *
+     * A genuine `connected` transition cannot double-emit alongside this seed.
+     * `config.subscribe` only fires on change, and the connect branch treats a
+     * re-entry for an already-tracked address as a no-op (or a chain change).
+     */
+    WagmiEventHandler.prototype.seedFromCurrentState = function () {
+        var _a, _b;
+        try {
+            var state = this.getState();
+            if (state.status !== "connected") {
+                return;
+            }
+            var address = this.getConnectedAddress(state);
+            // The active connection's chain is authoritative. `state.chainId` is a
+            // single global value that can lag or describe a different connection,
+            // and with `syncConnectedChain: false` it stays on the chain the APP
+            // selected while the connection reports what the WALLET is on.
+            var chainId = (_a = this.getActiveConnectionChainId(state)) !== null && _a !== void 0 ? _a : state.chainId;
+            if (!address || chainId === undefined) {
+                logger.debug("WagmiEventHandler: Connected at init but address or chainId is missing, nothing to seed", { address: address, chainId: chainId });
+                return;
+            }
+            logger.info("WagmiEventHandler: Adopting connection that predates this handler", { address: address, chainId: chainId });
+            // Sync central state first so tracking.excludeChains is enforced even
+            // when connect autocapture is disabled.
+            this.formo.syncWalletState({ chainId: chainId, address: address });
+            // Only adopt the wallet privately if central state actually accepted it.
+            // While tracking is suppressed (opt-out, excluded host or path)
+            // syncWalletState deliberately refuses to learn a wallet. Retaining it
+            // here anyway would let the mutation handlers attribute signatures and
+            // transactions to an address the SDK has decided it must not know -
+            // including on a chain that excludeChains rejects, since that check
+            // reads the central field rather than the event payload.
+            //
+            // Compared case-insensitively: syncWalletState stores the checksummed
+            // form, which need not match the casing wagmi reported.
+            if (((_b = this.formo.currentAddress) === null || _b === void 0 ? void 0 : _b.toLowerCase()) !== address.toLowerCase()) {
+                logger.debug("WagmiEventHandler: Central state declined the connection, not seeding", { address: address, chainId: chainId });
+                return;
+            }
+            // Adopt the tracking state either way - the mutation handlers need an
+            // address - but only emit the first time this page load adopts this
+            // wallet. A rebuilt SDK instance over an unchanged connection is a
+            // lifecycle event, not a user action.
+            this.trackingState.lastAddress = address;
+            this.trackingState.lastChainId = chainId;
+            this.trackingState.lastStatus = state.status;
+            // Always record the connection, including on the deduplicated path
+            // below. A replacement handler that adopts a live connection must be
+            // able to clear the right marker when it later sees the disconnect.
+            this.trackingState.lastConnectionId = state.current;
+            if (!this.formo.isAutocaptureEnabled("connect") || !this.isEmittingOwner) {
+                // Nothing was announced, so nothing may be marked. Marking here would
+                // make a later rebuild with connect autocapture enabled - which is
+                // exactly how FormoAnalyticsProvider applies an options change - find
+                // the marker and stay silent about a wallet it never reported.
+                logger.debug("WagmiEventHandler: Connect autocapture disabled, adopted without emitting", { address: address, chainId: chainId });
+                return;
+            }
+            // Nothing that will not actually be sent may be marked. `syncWalletState`
+            // accepts a wallet that `trackEvent()` then silently drops - `tracking:
+            // false`, or a chain in `excludeChains` - and marking it would make the
+            // rebuild that turns tracking back on find the marker and stay quiet
+            // about the wallet for the rest of the page load.
+            if (!this.formo.willTrackEvent(chainId)) {
+                logger.debug("WagmiEventHandler: Connect would not be tracked, adopted without emitting", { address: address, chainId: chainId });
+                return;
+            }
+            var walletKey_1 = announceKey(this.formo.writeKey, address);
+            var connection_1 = state.current
+                ? state.connections.get(state.current)
+                : undefined;
+            if (announcementState(walletKey_1, connection_1) !== "none") {
+                logger.debug("WagmiEventHandler: Wallet already adopted this page load, not re-emitting connect", { address: address });
+                return;
+            }
+            markAnnounced(walletKey_1, connection_1);
+            {
+                var connectorName = this.getConnectorName(state);
+                // Invoked synchronously, only the completion is fire-and-forget.
+                //
+                // Deferring the call itself to a microtask and guarding it on
+                // `disposed` loses the event outright: a rebuild that tears this
+                // handler down before the microtask runs leaves the marker standing,
+                // so the replacement handler suppresses its own connect while this one
+                // declines to emit. Nobody reports the wallet. Calling now means the
+                // marker and the emission are decided together, and a rebuild can only
+                // arrive after the event is already handed to FormoAnalytics.
+                void Promise.resolve(this.formo.connect({ chainId: chainId, address: address }, __assign({}, (connectorName && { providerName: connectorName })))).catch(function (error) {
+                    // The marker is a claim, not a record. If the emission failed the
+                    // wallet was never reported, so release it - otherwise a retry or a
+                    // replacement handler treats it as done and the connect is lost for
+                    // the rest of the page load even once the queue recovers.
+                    releaseAnnouncement(walletKey_1, connection_1);
+                    logger.error("WagmiEventHandler: Error emitting seeded connect event:", error);
+                });
+            }
+        }
+        catch (error) {
+            logger.error("WagmiEventHandler: Error seeding from current state:", error);
+        }
+    };
+    /**
+     * Re-assert the tracked wallet into central state.
+     *
+     * Needed when an awaited emission clears the central namespace after a newer
+     * transition has already adopted a different wallet: the two then disagree,
+     * and `trackEvent()` reads the central one.
+     */
+    WagmiEventHandler.prototype.restoreCentralStateFromTracking = function () {
+        var _a;
+        var _b = this.trackingState, lastAddress = _b.lastAddress, lastChainId = _b.lastChainId;
+        if (!lastAddress || lastChainId === undefined)
+            return;
+        // Compares the CHAIN as well as the address.
+        //
+        // A chain switch on an excluded path is deliberately refused by
+        // `syncWalletState()`, so central state keeps the old chain while
+        // `lastChainId` moves on. Matching on the address alone returned here,
+        // and after navigating back to an allowed path the events that fall back
+        // to the central chain were gated against a chain the wallet had left -
+        // bypassing an exclusion covering where it actually was.
+        if (((_a = this.formo.currentAddress) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === lastAddress.toLowerCase() &&
+            this.formo.currentChainId === lastChainId) {
+            return;
+        }
+        logger.info("WagmiEventHandler: Restoring central state a stale disconnect cleared", { address: lastAddress, chainId: lastChainId });
+        this.formo.syncWalletState({ chainId: lastChainId, address: lastAddress });
+    };
+    /**
+     * Drop the wallet this handler is attributing events to.
+     *
+     * Used whenever central state refuses to hold the wallet - an excluded path
+     * or chain, or an opt-out. Keeping the address privately would let the
+     * mutation handlers label signatures and transactions with an identity the
+     * SDK has deliberately declined to know.
+     */
+    WagmiEventHandler.prototype.releaseTrackedWallet = function () {
+        var previous = this.trackingState.lastAddress;
+        this.trackingState.lastAddress = undefined;
+        this.trackingState.lastChainId = undefined;
+        this.trackingState.lastConnectionId = undefined;
+        if (previous) {
+            announcedConnections.delete(announceKey(this.formo.writeKey, previous));
+        }
+    };
+    /**
+     * Adopt the live connection if one exists and nothing is tracked yet.
+     *
+     * `seedFromCurrentState()` runs once at construction and can legitimately
+     * decline: wagmi may still be filling `connections`, the chain may not have
+     * arrived, or tracking may be suppressed because the app happens to be on an
+     * excluded path. `config.subscribe` only reports *changes*, so an unchanged
+     * connection would then stay invisible for the rest of the page load and
+     * every later signature and transaction would be dropped.
+     *
+     * Idempotent. The page-load marker keeps it from re-emitting a connect for a
+     * wallet already announced, so this is safe to call from any listener.
+     */
+    WagmiEventHandler.prototype.retryAdoption = function () {
+        if (this.disposed)
+            return;
+        // The cached wallet may no longer be the live one. While tracking is
+        // suppressed a user can disconnect, or switch account inside the same
+        // wallet - which moves only the connection's accounts, so neither the
+        // status nor the chain subscription fires and nothing tells this handler.
+        // Restoring the cached wallet then resurrects an address the user has
+        // left, and the marker makes the check below return before the live one
+        // is ever adopted.
+        if (this.trackingState.lastAddress && !this.tracksLiveWallet()) {
+            logger.debug("WagmiEventHandler: Tracked wallet is no longer the live one, releasing before retry", { tracked: this.trackingState.lastAddress });
+            this.releaseTrackedWallet();
+        }
+        // Central state can have been cleared underneath a wallet this handler is
+        // still tracking: `optOutTracking()` calls `reset()`, which wipes
+        // `currentAddress` / `currentChainId` while the handler keeps its wallet.
+        // Left unreconciled, later events carry no wallet at all - and
+        // `shouldTrack()` sees no chain, so `excludeChains` stops excluding.
+        this.resyncCentralState();
+        // Adopted is not the same as announced. A wallet connected on an excluded
+        // chain, or while tracking was off, is adopted so mutations can be
+        // attributed, but its connect is deliberately not emitted or marked. If
+        // this returned merely because an address is present, that wallet would
+        // never be reported once the chain or configuration allowed it.
+        if (this.trackingState.lastAddress && this.isCurrentWalletAnnounced()) {
+            return;
+        }
+        this.seedFromCurrentState();
+    };
+    /** Whether the wallet this handler tracks is the one wagmi currently has. */
+    WagmiEventHandler.prototype.tracksLiveWallet = function () {
+        var tracked = this.trackingState.lastAddress;
+        if (!tracked)
+            return false;
+        try {
+            var state = this.getState();
+            if (state.status !== "connected")
+                return false;
+            var live = this.getConnectedAddress(state);
+            return !!live && live.toLowerCase() === tracked.toLowerCase();
+        }
+        catch (error) {
+            logger.error("WagmiEventHandler: Error reading state to compare wallets:", error);
+            return false;
+        }
+    };
+    /**
+     * Put the tracked wallet back into central state without emitting anything.
+     *
+     * Used when the two have diverged for a reason that is not a wallet change:
+     * an opt-out `reset()`, or a stale disconnect completing after a newer
+     * transition adopted a different wallet.
+     */
+    WagmiEventHandler.prototype.resyncCentralState = function () {
+        var _a;
+        var _b = this.trackingState, lastAddress = _b.lastAddress, lastChainId = _b.lastChainId;
+        if (!lastAddress || lastChainId === undefined)
+            return;
+        // Compares the CHAIN as well as the address.
+        //
+        // A chain switch on an excluded path is deliberately refused by
+        // `syncWalletState()`, so central state keeps the old chain while
+        // `lastChainId` moves on. Matching on the address alone returned here,
+        // and after navigating back to an allowed path the events that fall back
+        // to the central chain were gated against a chain the wallet had left -
+        // bypassing an exclusion covering where it actually was.
+        if (((_a = this.formo.currentAddress) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === lastAddress.toLowerCase() &&
+            this.formo.currentChainId === lastChainId) {
+            return;
+        }
+        logger.info("WagmiEventHandler: Re-syncing central state for a tracked wallet", {
+            address: lastAddress,
+            chainId: lastChainId,
+        });
+        this.formo.syncWalletState({ chainId: lastChainId, address: lastAddress });
+    };
+    /** Whether the wallet currently tracked has already had a connect emitted. */
+    WagmiEventHandler.prototype.isCurrentWalletAnnounced = function () {
+        var address = this.trackingState.lastAddress;
+        if (!address)
+            return false;
+        var connection;
+        try {
+            var state = this.getState();
+            connection = state.current
+                ? state.connections.get(state.current)
+                : undefined;
+        }
+        catch (_a) {
+            /* fall back to the address-keyed marker */
+        }
+        return (announcementState(announceKey(this.formo.writeKey, address), connection) !==
+            "none");
+    };
     /**
      * Handle status changes (connect/disconnect)
      */
     WagmiEventHandler.prototype.handleStatusChange = function (status, prevStatus) {
         return __awaiter(this, void 0, void 0, function () {
-            var state, address, chainId, connectorName, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var state, address, chainId, disconnectedAddress, disconnectedChainId, walletKey, connection, connectorName, error_1, error_2;
+            var _a, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         // Prevent concurrent processing
                         if (this.trackingState.isProcessing) {
+                            // Dropped, not queued - but remember that a disconnect went past.
+                            //
+                            // Reconciliation compares only the FINAL state, so a wallet that
+                            // disconnects and reconnects entirely inside this window looks
+                            // unchanged and neither its disconnect nor its genuine reconnect is
+                            // ever reported. Recording the transient lets reconciliation tell that
+                            // cycle apart from nothing having happened at all.
+                            if (status === "disconnected") {
+                                this.missedDisconnect = true;
+                            }
                             logger.debug("WagmiEventHandler: Already processing status change, skipping");
                             return [2 /*return*/];
                         }
                         this.trackingState.isProcessing = true;
-                        _a.label = 1;
+                        // A status change outranks any connection transition still in flight. A
+                        // full disconnect advances no ticket of its own, so without this an older
+                        // fallback continuation could resume and announce a wallet wagmi no longer
+                        // has.
+                        this.transitionGeneration += 1;
+                        _e.label = 1;
                     case 1:
-                        _a.trys.push([1, 7, 8, 9]);
+                        _e.trys.push([1, 14, 15, 16]);
                         state = this.getState();
                         address = this.getConnectedAddress(state);
-                        chainId = state.chainId;
+                        chainId = (_a = this.getActiveConnectionChainId(state)) !== null && _a !== void 0 ? _a : state.chainId;
                         logger.info("WagmiEventHandler: Status changed", {
                             status: status,
                             prevStatus: prevStatus,
                             address: address,
                             chainId: chainId,
                         });
-                        if (!(status === "disconnected" && prevStatus === "connected")) return [3 /*break*/, 4];
-                        // Clear central chain state regardless of autocapture so a later
-                        // event can't carry a stale excluded/!excluded chainId.
-                        this.formo.syncWalletState({
-                            chainId: this.trackingState.lastChainId,
-                        });
-                        if (!this.formo.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 3];
+                        if (!(status === "disconnected" && this.trackingState.lastAddress)) return [3 /*break*/, 4];
+                        disconnectedAddress = this.trackingState.lastAddress;
+                        disconnectedChainId = this.trackingState.lastChainId;
+                        this.trackingState.lastConnectionId = undefined;
+                        this.trackingState.lastAddress = undefined;
+                        this.trackingState.lastChainId = undefined;
+                        this.pendingChainId = undefined;
+                        this.missedDisconnect = false;
+                        // A real disconnect ends the adoption, so a genuine reconnect later in
+                        // this same page load emits again.
+                        announcedConnections.delete(announceKey(this.formo.writeKey, disconnectedAddress));
+                        if (!(this.formo.isAutocaptureEnabled("disconnect") && this.isEmittingOwner)) return [3 /*break*/, 3];
                         return [4 /*yield*/, this.formo.disconnect({
-                                chainId: this.trackingState.lastChainId,
-                                address: this.trackingState.lastAddress,
+                                chainId: disconnectedChainId,
+                                address: disconnectedAddress,
                             })];
                     case 2:
-                        _a.sent();
-                        _a.label = 3;
+                        _e.sent();
+                        return [3 /*break*/, 4];
                     case 3:
-                        this.trackingState.lastAddress = undefined;
-                        this.trackingState.lastChainId = undefined;
-                        _a.label = 4;
+                        // Nothing to emit, but central state must still be cleared so a
+                        // later event cannot carry a stale excluded/!excluded chainId.
+                        this.formo.syncWalletState({ chainId: disconnectedChainId });
+                        _e.label = 4;
                     case 4:
-                        if (!(status === "connected" && prevStatus !== "connected")) return [3 /*break*/, 6];
-                        if (!(address && chainId !== undefined)) return [3 /*break*/, 6];
+                        if (!(status === "connected" && prevStatus !== "connected")) return [3 /*break*/, 13];
+                        if (!(address && chainId !== undefined)) return [3 /*break*/, 13];
+                        if (!(((_b = this.trackingState.lastAddress) === null || _b === void 0 ? void 0 : _b.toLowerCase()) ===
+                            address.toLowerCase())) return [3 /*break*/, 9];
+                        if (!(this.trackingState.lastChainId !== chainId)) return [3 /*break*/, 7];
+                        if (!(this.pendingChainId === chainId)) return [3 /*break*/, 6];
+                        this.pendingChainId = undefined;
+                        logger.info("WagmiEventHandler: Re-entry carries a chain the subscription dropped, emitting it", { address: address, from: this.trackingState.lastChainId, to: chainId });
+                        return [4 /*yield*/, this.handleChainChange(chainId, this.trackingState.lastChainId)];
+                    case 5:
+                        _e.sent();
+                        this.trackingState.lastStatus = status;
+                        return [2 /*return*/];
+                    case 6:
+                        logger.info("WagmiEventHandler: Tracked wallet re-entered connected on a different chain", { address: address, from: this.trackingState.lastChainId, to: chainId });
+                        // Sync first, then adopt only if central state accepted it.
+                        // Writing the private chain first would let the mutation
+                        // handlers label events with a chain that `shouldTrack()` is
+                        // still excluding, because that gate reads the central field
+                        // rather than the event payload.
+                        this.formo.syncWalletState({ chainId: chainId, address: address });
+                        if (((_c = this.formo.currentAddress) === null || _c === void 0 ? void 0 : _c.toLowerCase()) ===
+                            address.toLowerCase()) {
+                            this.trackingState.lastChainId = chainId;
+                        }
+                        else {
+                            logger.debug("WagmiEventHandler: Central state declined the re-entry chain, dropping the wallet", { address: address, chainId: chainId });
+                            this.releaseTrackedWallet();
+                        }
+                        return [3 /*break*/, 8];
+                    case 7:
+                        logger.debug("WagmiEventHandler: Ignoring re-entry to connected for an already tracked wallet", { address: address, chainId: chainId });
+                        _e.label = 8;
+                    case 8:
+                        this.trackingState.lastStatus = status;
+                        return [2 /*return*/];
+                    case 9:
+                        // Sync central state first so tracking.excludeChains is enforced
+                        // even when connect autocapture is disabled.
+                        this.formo.syncWalletState({ chainId: chainId, address: address });
+                        // Same rule as the seed and the account-switch path: while tracking
+                        // is suppressed, syncWalletState refuses to learn a wallet, and
+                        // retaining it privately would let the mutation handlers attribute
+                        // events to an address the SDK declined to know.
+                        if (((_d = this.formo.currentAddress) === null || _d === void 0 ? void 0 : _d.toLowerCase()) !== address.toLowerCase()) {
+                            logger.debug("WagmiEventHandler: Central state declined the connection, not adopting", { address: address, chainId: chainId });
+                            this.trackingState.lastStatus = status;
+                            return [2 /*return*/];
+                        }
+                        // A wallet superseded without an intervening `disconnected` - a
+                        // `reconnecting` flap landing on a different account - is handled by
+                        // `reconcileWithLiveState()`, which releases the old wallet (and its
+                        // marker) before re-seeding. Nothing to do here.
                         this.trackingState.lastAddress = address;
                         this.trackingState.lastChainId = chainId;
-                        // Sync central state unconditionally so tracking.excludeChains
-                        // is enforced even when connect autocapture is disabled.
-                        this.formo.syncWalletState({ chainId: chainId, address: address });
-                        if (!this.formo.isAutocaptureEnabled("connect")) return [3 /*break*/, 6];
+                        this.trackingState.lastConnectionId = state.current;
+                        if (!(this.formo.isAutocaptureEnabled("connect") &&
+                            this.isEmittingOwner &&
+                            this.formo.willTrackEvent(chainId))) return [3 /*break*/, 13];
+                        walletKey = announceKey(this.formo.writeKey, address);
+                        connection = state.current
+                            ? state.connections.get(state.current)
+                            : undefined;
+                        if (announcementState(walletKey, connection) !== "none") {
+                            logger.debug("WagmiEventHandler: Connect already announced for this wallet, not emitting again", { address: address });
+                            this.trackingState.lastStatus = status;
+                            return [2 /*return*/];
+                        }
+                        markAnnounced(walletKey, connection);
                         connectorName = this.getConnectorName(state);
+                        _e.label = 10;
+                    case 10:
+                        _e.trys.push([10, 12, , 13]);
                         return [4 /*yield*/, this.formo.connect({ chainId: chainId, address: address }, __assign({}, (connectorName && { providerName: connectorName })))];
-                    case 5:
-                        _a.sent();
-                        _a.label = 6;
-                    case 6:
+                    case 11:
+                        _e.sent();
+                        return [3 /*break*/, 13];
+                    case 12:
+                        error_1 = _e.sent();
+                        // As in the seed: an emission that failed reported nothing, so
+                        // the claim must not stand.
+                        releaseAnnouncement(walletKey, connection);
+                        throw error_1;
+                    case 13:
                         this.trackingState.lastStatus = status;
-                        return [3 /*break*/, 9];
-                    case 7:
-                        error_1 = _a.sent();
-                        logger.error("WagmiEventHandler: Error handling status change:", error_1);
-                        return [3 /*break*/, 9];
-                    case 8:
+                        return [3 /*break*/, 16];
+                    case 14:
+                        error_2 = _e.sent();
+                        logger.error("WagmiEventHandler: Error handling status change:", error_2);
+                        return [3 /*break*/, 16];
+                    case 15:
                         this.trackingState.isProcessing = false;
+                        // A status change that arrived while the lock was held was dropped, not
+                        // queued. Reconcile against live state so the handler cannot be left
+                        // permanently disagreeing with wagmi.
+                        this.reconcileWithLiveState();
                         return [7 /*endfinally*/];
-                    case 9: return [2 /*return*/];
+                    case 16: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Re-run the status logic when the handler's view diverges from wagmi.
+     *
+     * `handleStatusChange()` drops - rather than defers - anything that arrives
+     * while it holds `isProcessing`, and it holds that lock across an awaited
+     * `connect()` / `disconnect()` emission. A wallet that reconnects inside
+     * that window would otherwise leave the handler believing it is
+     * disconnected for the rest of the page load, silently dropping every later
+     * signature and transaction. The mirror case leaves a disconnected wallet
+     * marked connected.
+     *
+     * Converges: each pass either adopts the live wallet or releases the tracked
+     * one, so the next pass finds the two in agreement and returns.
+     */
+    WagmiEventHandler.prototype.reconcileWithLiveState = function () {
+        var _this = this;
+        if (this.disposed || this.trackingState.isProcessing)
+            return;
+        if (this.reconciling)
+            return;
+        var state;
+        try {
+            state = this.getState();
+        }
+        catch (error) {
+            logger.error("WagmiEventHandler: Error reading state to reconcile:", error);
+            return;
+        }
+        // `connecting` and `reconnecting` are transient: the wallet has not gone
+        // anywhere, wagmi is mid-handshake. Treating them as disconnected made
+        // reconciliation synthesize a disconnect for an ordinary reconnect flap
+        // and then emit a second connect when it completed - two spurious events
+        // for a wallet that never left.
+        if (state.status !== "connected" && state.status !== "disconnected") {
+            return;
+        }
+        var live = state.status === "connected" ? this.getConnectedAddress(state) : undefined;
+        var tracked = this.trackingState.lastAddress;
+        if (!live && !tracked)
+            return;
+        if (live && tracked) {
+            if (live.toLowerCase() === tracked.toLowerCase()) {
+                if (this.missedDisconnect) {
+                    // The wallet went away and came back entirely while the lock was
+                    // held. The addresses match, but this is a new session: report the
+                    // disconnect, then let the reconnect announce itself.
+                    this.missedDisconnect = false;
+                    logger.info("WagmiEventHandler: A disconnect/reconnect cycle completed while the lock was held", { address: live });
+                    this.reconciling = true;
+                    try {
+                        void this.handleStatusChange("disconnected", "connected").then(function () {
+                            return _this.retryAdoption();
+                        });
+                    }
+                    finally {
+                        this.reconciling = false;
+                    }
+                    return;
+                }
+                // Same wallet. Replay a chain change the chain callback had to drop
+                // because wagmi was still `reconnecting` at the time - the status
+                // callback that would have covered it was then dropped by the
+                // processing guard, so without this both the tracked and the central
+                // chain keep describing the chain the wallet has already left.
+                //
+                // Deliberately keyed on a chain the callback actually dropped rather
+                // than on any difference: in the ordinary flap the chain subscription
+                // still owns the emission, and reconciling on difference alone would
+                // double count it.
+                // A disconnect that completed after a newer transition re-adopted this
+                // same wallet clears the central namespace on its way out. Private
+                // tracking still names the wallet while central state is empty, and
+                // `trackEvent()` reads the central one - so later events lose their
+                // wallet entirely. Put it back.
+                this.resyncCentralState();
+                var dropped = this.pendingChainId;
+                if (dropped !== undefined) {
+                    this.pendingChainId = undefined;
+                    if (dropped !== this.trackingState.lastChainId) {
+                        logger.info("WagmiEventHandler: Replaying a chain change dropped while reconnecting", { address: live, from: this.trackingState.lastChainId, to: dropped });
+                        void this.handleChainChange(dropped, this.trackingState.lastChainId);
+                    }
+                }
+                return;
+            }
+            // Different wallet. Wagmi moved from one to another while the lock was
+            // held, so BOTH status callbacks were dropped. Returning here would
+            // leave every later signature and transaction attributed to the wallet
+            // the user has already left.
+            logger.info("WagmiEventHandler: Wallet changed while the lock was held, re-adopting", { from: tracked, to: live });
+            this.reconciling = true;
+            try {
+                this.releaseTrackedWallet();
+                this.seedFromCurrentState();
+            }
+            finally {
+                this.reconciling = false;
+            }
+            return;
+        }
+        this.reconciling = true;
+        try {
+            if (live) {
+                logger.info("WagmiEventHandler: Reconnect landed while the lock was held, adopting it", { address: live });
+                this.retryAdoption();
+            }
+            else {
+                logger.info("WagmiEventHandler: Disconnect landed while the lock was held, applying it", { address: tracked });
+                void this.handleStatusChange("disconnected", "connected");
+            }
+        }
+        finally {
+            this.reconciling = false;
+        }
+    };
+    /**
+     * Handle a switch to a different account on an already-connected wallet.
+     *
+     * Only fires for a genuine in-place switch. A fresh connect and a disconnect
+     * both move `state.status`, and that listener is registered first, so it has
+     * already recorded the new address synchronously by the time this runs. The
+     * `lastAddress` check below is what makes the two paths mutually exclusive.
+     */
+    WagmiEventHandler.prototype.handleActiveAddressChange = function (address, prevAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var state, trackedConnectionId, trackedConnectionGone, connectionChanged, liveChain, generation, chainId, stillConnected, goneChainId, error_3, liveNow, stillCurrent, walletKey, connection, alreadyAnnounced, connectorName, error_4;
+            var _a, _b, _c, _d, _e, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        state = this.getState();
+                        if (state.status !== "connected")
+                            return [2 /*return*/];
+                        trackedConnectionId = this.trackingState.lastConnectionId;
+                        trackedConnectionGone = !!trackedConnectionId && !state.connections.has(trackedConnectionId);
+                        connectionChanged = this.trackingState.lastConnectionId !== undefined &&
+                            state.current !== undefined &&
+                            state.current !== this.trackingState.lastConnectionId;
+                        if (!trackedConnectionGone && !connectionChanged) {
+                            if (!address || address === prevAddress)
+                                return [2 /*return*/];
+                            // Already handled by the status listener (fresh connect, or the seed).
+                            // Case-insensitive, like every other address comparison here.
+                            if (((_a = this.trackingState.lastAddress) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === address.toLowerCase()) {
+                                return [2 /*return*/];
+                            }
+                        }
+                        if (!(connectionChanged &&
+                            !trackedConnectionGone &&
+                            address &&
+                            ((_b = this.trackingState.lastAddress) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === address.toLowerCase())) return [3 /*break*/, 3];
+                        liveChain = (_c = this.getActiveConnectionChainId(state)) !== null && _c !== void 0 ? _c : state.chainId;
+                        logger.info("WagmiEventHandler: Active connection changed for the same account", { address: address, from: this.trackingState.lastConnectionId, to: state.current });
+                        this.trackingState.lastConnectionId = state.current;
+                        if (!(liveChain !== undefined && liveChain !== this.trackingState.lastChainId)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.applyChainForTrackedWallet(address, liveChain)];
+                    case 1:
+                        _g.sent();
+                        _g.label = 2;
+                    case 2: return [2 /*return*/];
+                    case 3:
+                        if (!address)
+                            return [2 /*return*/];
+                        generation = ++this.transitionGeneration;
+                        chainId = (_d = this.getActiveConnectionChainId(state)) !== null && _d !== void 0 ? _d : state.chainId;
+                        if (chainId === undefined)
+                            return [2 /*return*/];
+                        if (!trackedConnectionGone) return [3 /*break*/, 14];
+                        stillConnected = !!prevAddress && this.isAddressConnected(state, prevAddress);
+                        if (!stillConnected) return [3 /*break*/, 7];
+                        // The connector went away but the ACCOUNT did not: another live
+                        // connection still holds it. Nothing disconnected from the user's
+                        // point of view, so no event - just follow the connection.
+                        logger.info("WagmiEventHandler: Tracked connector fell away, account still connected elsewhere", { address: prevAddress, connection: state.current });
+                        this.trackingState.lastConnectionId = state.current;
+                        if (!(((_e = this.trackingState.lastAddress) === null || _e === void 0 ? void 0 : _e.toLowerCase()) === address.toLowerCase())) return [3 /*break*/, 6];
+                        if (!(this.trackingState.lastChainId !== chainId)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.applyChainForTrackedWallet(address, chainId)];
+                    case 4:
+                        _g.sent();
+                        _g.label = 5;
+                    case 5: return [2 /*return*/];
+                    case 6: return [3 /*break*/, 14];
+                    case 7:
+                        if (!prevAddress) return [3 /*break*/, 14];
+                        logger.info("WagmiEventHandler: Tracked connector disconnected, wagmi fell back to another connection", { disconnected: prevAddress, fallback: address });
+                        goneChainId = this.trackingState.lastChainId;
+                        this.releaseTrackedWallet();
+                        if (!(this.formo.isAutocaptureEnabled("disconnect") && this.isEmittingOwner)) return [3 /*break*/, 12];
+                        _g.label = 8;
+                    case 8:
+                        _g.trys.push([8, 10, , 11]);
+                        // Emitted before central state is cleared, so excludeChains can
+                        // still gate it on the chain the wallet was actually on.
+                        return [4 /*yield*/, this.formo.disconnect({
+                                chainId: goneChainId,
+                                address: prevAddress,
+                            })];
+                    case 9:
+                        // Emitted before central state is cleared, so excludeChains can
+                        // still gate it on the chain the wallet was actually on.
+                        _g.sent();
+                        return [3 /*break*/, 11];
+                    case 10:
+                        error_3 = _g.sent();
+                        logger.error("WagmiEventHandler: Error tracking connector fallback disconnect:", error_3);
+                        return [3 /*break*/, 11];
+                    case 11: return [3 /*break*/, 13];
+                    case 12:
+                        this.formo.syncWalletState({ chainId: goneChainId });
+                        _g.label = 13;
+                    case 13:
+                        liveNow = void 0;
+                        try {
+                            liveNow = this.getState();
+                        }
+                        catch (_h) {
+                            /* treated as superseded below */
+                        }
+                        stillCurrent = !this.disposed &&
+                            (liveNow === null || liveNow === void 0 ? void 0 : liveNow.status) === "connected" &&
+                            liveNow.current === state.current;
+                        if (generation !== this.transitionGeneration || !stillCurrent) {
+                            logger.debug("WagmiEventHandler: A newer transition superseded this one, stopping", { address: address });
+                            // `disconnect()` clears the central wallet namespace as it
+                            // completes, and it has just done so on top of whatever the newer
+                            // transition adopted. Private tracking still names the new wallet
+                            // while central state is empty, which silently drops the address and
+                            // chain from every later event. Put back what is actually live.
+                            this.restoreCentralStateFromTracking();
+                            return [2 /*return*/];
+                        }
+                        _g.label = 14;
+                    case 14:
+                        logger.info("WagmiEventHandler: Active account switched", {
+                            from: prevAddress,
+                            to: address,
+                            chainId: chainId,
+                        });
+                        // Sync central state first so tracking.excludeChains is enforced even when
+                        // connect autocapture is disabled.
+                        this.formo.syncWalletState({ chainId: chainId, address: address });
+                        // Same rule as the seed: while tracking is suppressed, syncWalletState
+                        // refuses to learn a wallet, and retaining it privately would let the
+                        // mutation handlers attribute events to an address the SDK declined to
+                        // know. Compared case-insensitively because the checksummed form is stored.
+                        if (((_f = this.formo.currentAddress) === null || _f === void 0 ? void 0 : _f.toLowerCase()) !== address.toLowerCase()) {
+                            logger.debug("WagmiEventHandler: Central state declined the switched account, not adopting", { address: address, chainId: chainId });
+                            // Drop the previous wallet too. The user has moved off it, so leaving it
+                            // in tracking state would attribute this account's later signatures and
+                            // transactions to the account they switched away from - worse than
+                            // recording nothing.
+                            this.releaseTrackedWallet();
+                            return [2 /*return*/];
+                        }
+                        this.trackingState.lastAddress = address;
+                        this.trackingState.lastChainId = chainId;
+                        this.trackingState.lastConnectionId = state.current;
+                        if (!(this.formo.isAutocaptureEnabled("connect") &&
+                            this.isEmittingOwner &&
+                            this.formo.willTrackEvent(chainId))) return [3 /*break*/, 18];
+                        // Move the page-load marker onto the wallet that is now active.
+                        //
+                        // Gated on ownership as well, like the ordinary connect path. A
+                        // non-owner that marked here would make the real owner find the marker
+                        // and stay silent, and the non-owner's own emission dies with its queue
+                        // when that instance is torn down - losing the connect entirely.
+                        //
+                        // Only drop the previous wallet's marker when that wallet is genuinely
+                        // gone. On an in-place account switch the old account leaves the
+                        // connection and must be able to announce itself again later. But with
+                        // several connections the previous wallet is often still connected -
+                        // it merely stopped being `state.current` - and forgetting it there
+                        // would make it re-announce every time wagmi switched back.
+                        if (prevAddress && !this.isAddressConnected(state, prevAddress)) {
+                            announcedConnections.delete(announceKey(this.formo.writeKey, prevAddress));
+                        }
+                        walletKey = announceKey(this.formo.writeKey, address);
+                        connection = state.current
+                            ? state.connections.get(state.current)
+                            : undefined;
+                        alreadyAnnounced = announcementState(walletKey, connection) !== "none";
+                        markAnnounced(walletKey, connection);
+                        if (alreadyAnnounced) {
+                            // Reached by the connector-fallback path above: wagmi made a
+                            // connection active that this page load already reported. Becoming
+                            // active is not a new connect.
+                            logger.debug("WagmiEventHandler: Fallback connection was already announced, not re-emitting connect", { address: address });
+                            return [2 /*return*/];
+                        }
+                        _g.label = 15;
+                    case 15:
+                        _g.trys.push([15, 17, , 18]);
+                        connectorName = this.getConnectorName(state);
+                        return [4 /*yield*/, this.formo.connect({ chainId: chainId, address: address }, __assign({}, (connectorName && { providerName: connectorName })))];
+                    case 16:
+                        _g.sent();
+                        return [3 /*break*/, 18];
+                    case 17:
+                        error_4 = _g.sent();
+                        releaseAnnouncement(walletKey, connection);
+                        logger.error("WagmiEventHandler: Error tracking account switch:", error_4);
+                        return [3 /*break*/, 18];
+                    case 18: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Record and emit a chain move for the wallet already being tracked.
+     *
+     * Shared by `handleChainChange()` and the connector-fallback path, which
+     * has to apply the chain itself: the chain callback defers while the new
+     * connection is not adopted yet, so nothing else would.
+     */
+    WagmiEventHandler.prototype.applyChainForTrackedWallet = function (address, chainId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_5;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        // Sync central state unconditionally so a switch to an excluded chain is
+                        // honored even when chain autocapture is disabled.
+                        this.formo.syncWalletState({ chainId: chainId, address: address });
+                        if (((_a = this.formo.currentAddress) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== address.toLowerCase()) {
+                            logger.debug("WagmiEventHandler: Central state declined the new chain, dropping the wallet", { address: address, chainId: chainId });
+                            this.releaseTrackedWallet();
+                            return [2 /*return*/];
+                        }
+                        this.trackingState.lastChainId = chainId;
+                        if (!(this.formo.isAutocaptureEnabled("chain") && this.isEmittingOwner)) return [3 /*break*/, 4];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.formo.chain({ chainId: chainId, address: address })];
+                    case 2:
+                        _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_5 = _b.sent();
+                        logger.error("WagmiEventHandler: Error tracking chain change:", error_5);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
                 }
             });
         });
@@ -221,7 +1343,7 @@ var WagmiEventHandler = /** @class */ (function () {
      */
     WagmiEventHandler.prototype.handleChainChange = function (chainId, prevChainId) {
         return __awaiter(this, void 0, void 0, function () {
-            var state, address, error_2;
+            var state, address, hadAddress, wasAnnounced, announcedNow;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -230,35 +1352,48 @@ var WagmiEventHandler = /** @class */ (function () {
                         }
                         state = this.getState();
                         if (state.status !== "connected") {
+                            this.pendingChainId = chainId;
                             return [2 /*return*/];
                         }
+                        this.pendingChainId = undefined;
                         address = this.getConnectedAddress(state);
                         if (!address) {
                             logger.warn("WagmiEventHandler: Chain changed but no address found");
                             return [2 /*return*/];
                         }
+                        // Ignore a chain that belongs to a connection this handler has not adopted
+                        // yet.
+                        //
+                        // Both subscriptions fire for one wagmi update and this one can run first.
+                        // During a connector fallback that would overwrite `lastChainId` with the
+                        // INCOMING connection's chain, so the outgoing wallet's disconnect - which
+                        // the connection handler is about to emit - would be labelled with the
+                        // chain of the wallet that replaced it, and a spurious `chain` event would
+                        // be emitted for a wallet not yet adopted. The connection handler owns
+                        // that transition and records the chain itself.
+                        if (this.trackingState.lastConnectionId !== undefined &&
+                            state.current !== undefined &&
+                            state.current !== this.trackingState.lastConnectionId) {
+                            logger.debug("WagmiEventHandler: Chain change belongs to a connection not adopted yet, deferring", { chainId: chainId, from: this.trackingState.lastConnectionId, to: state.current });
+                            return [2 /*return*/];
+                        }
+                        hadAddress = !!this.trackingState.lastAddress;
+                        wasAnnounced = this.isCurrentWalletAnnounced();
+                        if (!hadAddress || !wasAnnounced) {
+                            this.retryAdoption();
+                            announcedNow = !wasAnnounced && this.isCurrentWalletAnnounced();
+                            if (announcedNow)
+                                return [2 /*return*/];
+                        }
                         logger.info("WagmiEventHandler: Chain changed", {
                             chainId: chainId,
                             prevChainId: prevChainId,
                             address: address,
                         });
-                        this.trackingState.lastChainId = chainId;
-                        // Sync central state unconditionally so a chain switch to an
-                        // excluded chain is honored even when chain autocapture is disabled.
-                        this.formo.syncWalletState({ chainId: chainId, address: address });
-                        if (!this.formo.isAutocaptureEnabled("chain")) return [3 /*break*/, 4];
-                        _a.label = 1;
+                        return [4 /*yield*/, this.applyChainForTrackedWallet(address, chainId)];
                     case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.formo.chain({ chainId: chainId, address: address })];
-                    case 2:
                         _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_2 = _a.sent();
-                        logger.error("WagmiEventHandler: Error tracking chain change:", error_2);
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
+                        return [2 /*return*/];
                 }
             });
         });
@@ -303,6 +1438,11 @@ var WagmiEventHandler = /** @class */ (function () {
         if (event.type !== "updated") {
             return;
         }
+        // Overlapping handlers share one MutationCache/QueryCache, so without
+        // this each of them emits for the same mutation.
+        if (!this.isEmittingOwner) {
+            return;
+        }
         var query = event.query;
         var queryKey = query.queryKey;
         if (!queryKey || queryKey.length === 0) {
@@ -348,7 +1488,7 @@ var WagmiEventHandler = /** @class */ (function () {
      * Emits CONFIRMED or REVERTED transaction status
      */
     WagmiEventHandler.prototype.handleTransactionReceiptQuery = function (query) {
-        var _a;
+        var _a, _b;
         if (!this.formo.isAutocaptureEnabled("transaction")) {
             return;
         }
@@ -362,7 +1502,8 @@ var WagmiEventHandler = /** @class */ (function () {
         // Query key format: ['waitForTransactionReceipt', { hash, chainId, ... }]
         var params = queryKey[1];
         var transactionHash = params === null || params === void 0 ? void 0 : params.hash;
-        var chainId = (params === null || params === void 0 ? void 0 : params.chainId) || this.trackingState.lastChainId;
+        // Resolved after the pending lookup below, so the broadcast chain wins.
+        var queryChainId = params === null || params === void 0 ? void 0 : params.chainId;
         if (!transactionHash) {
             logger.warn("WagmiEventHandler: Transaction receipt query but no hash found");
             return;
@@ -382,6 +1523,17 @@ var WagmiEventHandler = /** @class */ (function () {
             return;
         }
         var address = pendingTx.address;
+        // The chain the transaction was actually broadcast on wins, because the
+        // active chain can change between broadcast and receipt and would
+        // otherwise relabel the confirmation.
+        //
+        // Order: a chain the caller named explicitly, then the receipt query's own
+        // chain, then the chain we observed at broadcast time, then the current
+        // one. The inferred broadcast chain sits below the query's because the
+        // query names the chain the receipt was actually read from.
+        var chainId = pendingTx.chainIdWasExplicit
+            ? pendingTx.chainId
+            : (_a = queryChainId !== null && queryChainId !== void 0 ? queryChainId : pendingTx.chainId) !== null && _a !== void 0 ? _a : this.trackingState.lastChainId;
         if (!address) {
             logger.warn("WagmiEventHandler: Transaction receipt query but no address available");
             return;
@@ -403,7 +1555,7 @@ var WagmiEventHandler = /** @class */ (function () {
                 transactionHash: transactionHash,
                 address: address,
                 chainId: chainId,
-                blockNumber: (_a = receipt === null || receipt === void 0 ? void 0 : receipt.blockNumber) === null || _a === void 0 ? void 0 : _a.toString(),
+                blockNumber: (_b = receipt === null || receipt === void 0 ? void 0 : receipt.blockNumber) === null || _b === void 0 ? void 0 : _b.toString(),
             });
             this.formo.transaction(__assign(__assign(__assign(__assign(__assign({ status: txStatus, chainId: chainId || 0, address: address, transactionHash: transactionHash }, ((pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.data) && { data: pendingTx.data })), ((pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.to) && { to: pendingTx.to })), ((pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.value) && { value: pendingTx.value })), ((pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.function_name) && { function_name: pendingTx.function_name })), ((pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.function_args) && { function_args: pendingTx.function_args })), 
             // Spread function args as additional properties (only colliding keys are prefixed)
@@ -422,6 +1574,11 @@ var WagmiEventHandler = /** @class */ (function () {
         if (event.type !== "updated") {
             return;
         }
+        // Overlapping handlers share one MutationCache/QueryCache, so without
+        // this each of them emits for the same mutation.
+        if (!this.isEmittingOwner) {
+            return;
+        }
         var mutation = event.mutation;
         var mutationKey = mutation.options.mutationKey;
         if (!mutationKey || mutationKey.length === 0) {
@@ -462,13 +1619,28 @@ var WagmiEventHandler = /** @class */ (function () {
      * Handle signature mutations (signMessage, signTypedData)
      */
     WagmiEventHandler.prototype.handleSignatureMutation = function (mutationType, mutation) {
+        var _a, _b, _c, _d;
         if (!this.formo.isAutocaptureEnabled("signature")) {
             return;
         }
         var state = mutation.state;
         var variables = state.variables || {};
-        var chainId = this.trackingState.lastChainId;
-        var address = this.trackingState.lastAddress;
+        // An explicit per-call `account` wins over the active connection. wagmi
+        // lets a caller sign with an account other than the current one, and the
+        // tracked connection describes a different wallet in that case.
+        //
+        // For typed data the signed chain lives in the EIP-712 domain, not at the
+        // top level: `signTypedData` takes `{ domain, types, primaryType, message }`
+        // and the domain's `chainId` is what the signature is actually bound to.
+        // Reading only `variables.chainId` labelled such a signature with the
+        // wallet's current chain, which can be a different one entirely.
+        // Falls back to 0 - "could not resolve" - rather than undefined. A caller
+        // can name an account before any connection chain is known, and an
+        // undefined chain slipped past the exclusion gate, which only refuses an
+        // explicit 0. A chain-scoped event whose chain is unknown must fail
+        // closed like every other.
+        var chainId = (_d = (_c = (_b = normalizeChainId((_a = variables.domain) === null || _a === void 0 ? void 0 : _a.chainId)) !== null && _b !== void 0 ? _b : normalizeChainId(variables.chainId)) !== null && _c !== void 0 ? _c : this.trackingState.lastChainId) !== null && _d !== void 0 ? _d : 0;
+        var address = resolveAccountAddress(variables.account) || this.trackingState.lastAddress;
         if (!address) {
             logger.warn("WagmiEventHandler: Signature event but no address available");
             return;
@@ -522,15 +1694,26 @@ var WagmiEventHandler = /** @class */ (function () {
         }
         var state = mutation.state;
         var variables = state.variables || {};
-        var chainId = this.trackingState.lastChainId || variables.chainId;
-        // For sendTransaction, user's address is the 'from'
-        // For writeContract, variables.address is the contract address, not the user
-        // variables.account can be a string address or an Account object with an address property
-        var accountValue = variables.account;
-        var accountAddress = typeof accountValue === "string"
-            ? accountValue
-            : accountValue === null || accountValue === void 0 ? void 0 : accountValue.address;
-        var userAddress = this.trackingState.lastAddress || accountAddress || variables.from;
+        // Explicit per-call values win over the active connection. wagmi lets a
+        // caller target another account or chain, and the tracked connection
+        // describes a different wallet in that case. Fall back to the connection
+        // for the usual call that omits them.
+        //
+        // For sendTransaction the user's address is `from`; for writeContract
+        // `variables.address` is the contract, not the user.
+        // Distinguish an explicitly requested chain from one merely inferred from
+        // the active connection: only the former is authoritative for the receipt.
+        // Normalized: viem accepts a hex string or a bigint for `chainId`, and a
+        // non-number here would both land in the payload and defeat the numeric
+        // `tracking.excludeChains` comparison.
+        var explicitChainId = normalizeChainId(variables.chainId);
+        // Left undefined on purpose. The emission below already coerces with
+        // `chainId || 0`, and defaulting here instead would write 0 into the
+        // pending-transaction record, where an absent chain is what lets the
+        // receipt query's chain win for the confirmation.
+        var chainId = explicitChainId !== null && explicitChainId !== void 0 ? explicitChainId : this.trackingState.lastChainId;
+        var accountAddress = resolveAccountAddress(variables.account);
+        var userAddress = accountAddress || variables.from || this.trackingState.lastAddress;
         if (!userAddress) {
             logger.warn("WagmiEventHandler: Transaction event but no address available");
             return;
@@ -596,7 +1779,7 @@ var WagmiEventHandler = /** @class */ (function () {
             // Include the sender address to handle wallet switches between broadcast and confirmation
             if (status_2 === TransactionStatus.BROADCASTED && transactionHash) {
                 var normalizedHash = transactionHash.toLowerCase();
-                var txDetails = __assign(__assign(__assign(__assign(__assign(__assign({ address: userAddress }, (data && { data: data })), (to && { to: to })), (value && { value: value })), (function_name && { function_name: function_name })), (function_args && { function_args: function_args })), (safeFunctionArgs && { safeFunctionArgs: safeFunctionArgs }));
+                var txDetails = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ address: userAddress }, (chainId !== undefined && { chainId: chainId })), { chainIdWasExplicit: explicitChainId !== undefined }), (data && { data: data })), (to && { to: to })), (value && { value: value })), (function_name && { function_name: function_name })), (function_args && { function_args: function_args })), (safeFunctionArgs && { safeFunctionArgs: safeFunctionArgs }));
                 this.pendingTransactions.set(normalizedHash, txDetails);
                 logger.debug("WagmiEventHandler: Stored pending transaction for confirmation", {
                     transactionHash: normalizedHash,
@@ -641,6 +1824,21 @@ var WagmiEventHandler = /** @class */ (function () {
             chainId: undefined,
         };
     };
+    /**
+     * Chain of the connection that is currently active.
+     *
+     * Authoritative, because `state.chainId` is a single global value. With
+     * `syncConnectedChain: false` it stays on the chain the APP selected while
+     * the connection reports the chain the WALLET is actually on, so seeding
+     * from the global could label a wallet on an excluded chain as an allowed
+     * one and send events the exclusion forbids.
+     */
+    WagmiEventHandler.prototype.getActiveConnectionChainId = function (state) {
+        var _a;
+        if (!state.current)
+            return undefined;
+        return (_a = state.connections.get(state.current)) === null || _a === void 0 ? void 0 : _a.chainId;
+    };
     /**
      * Get the currently connected address from Wagmi state
      */
@@ -654,6 +1852,24 @@ var WagmiEventHandler = /** @class */ (function () {
         }
         return connection.accounts[0];
     };
+    /**
+     * Whether any live connection still holds this address.
+     *
+     * Distinguishes "the user switched away from this account" (gone from every
+     * connection) from "this account merely stopped being the current one"
+     * (still connected through its own connector).
+     */
+    WagmiEventHandler.prototype.isAddressConnected = function (state, address) {
+        var wanted = address.toLowerCase();
+        var found = false;
+        state.connections.forEach(function (connection) {
+            if (!found &&
+                connection.accounts.some(function (a) { return a.toLowerCase() === wanted; })) {
+                found = true;
+            }
+        });
+        return found;
+    };
     /**
      * Get the connector name from Wagmi state
      */
@@ -669,6 +1885,26 @@ var WagmiEventHandler = /** @class */ (function () {
      */
     WagmiEventHandler.prototype.cleanup = function () {
         logger.debug("WagmiEventHandler: Cleaning up subscriptions");
+        if (!this.disposed) {
+            this.disposed = true;
+            // Nothing in flight may complete against a torn-down handler.
+            this.transitionGeneration += 1;
+            // Give up the right to emit. Any other live handler for this
+            // destination claims it the next time it needs to emit.
+            if (this.ownerKey && emittingOwners.get(this.ownerKey) === this) {
+                emittingOwners.delete(this.ownerKey);
+            }
+            // Start the grace period. If nothing re-mounts, the markers are dropped
+            // so a reconnect that happens while unobserved still emits.
+            var wasLastForDestination = releaseMarkers(this.formo.writeKey);
+            // Drop the shared broadcast records rather than leak them - but only
+            // after the same grace period the markers get. The ordinary rebuild is
+            // cleanup THEN remount, so deleting immediately would lose the receipt
+            // for a transaction broadcast moments before teardown.
+            if (wasLastForDestination && this.ownerKey) {
+                schedulePendingTransactionExpiry(this.ownerKey);
+            }
+        }
         for (var _i = 0, _a = this.unsubscribers; _i < _a.length; _i++) {
             var unsubscribe = _a[_i];
             try {
@@ -681,7 +1917,10 @@ var WagmiEventHandler = /** @class */ (function () {
         this.unsubscribers = [];
         this.processedMutations.clear();
         this.processedQueries.clear();
-        this.pendingTransactions.clear();
+        // Deliberately NOT clearing `pendingTransactions`: it is shared per
+        // destination, and a replacement handler needs the broadcast records to
+        // match incoming receipts against. It is dropped when the last handler
+        // for the destination goes away (see below).
         logger.debug("WagmiEventHandler: Cleanup complete");
     };
     return WagmiEventHandler;