@formo/analytics 1.38.0 → 1.38.2

package/dist/cjs/src/evm/EvmProviderRegistry.d.ts

@@ -45,6 +45,24 @@ export declare class EvmProviderRegistry {
     private listeners;
     /** The window-injected provider, once detected, so it is not re-wrapped. */
     private injectedDetail?;
+    /**
+     * Attribution supplied by the integration layer for a provider that was
+     * never announced: the wagmi fallback wrap names a connector's provider
+     * after the CONNECTOR, so request-derived events carry the same wallet
+     * name as the hook-driven events from the same connection. Without it
+     * the name came from flag sniffing, and a custom or embedded connector
+     * whose provider exposes no recognised flag split one wallet's activity
+     * between "Injected Provider" and the connector's name.
+     *
+     * A RESOLVER, read at each `infoFor`, not a value: the name is live for
+     * the connector the integration layer bound it to (a WalletConnect
+     * session that resolves or changes its peer renames without a re-wrap),
+     * and the integration layer names events on its hook path with the same
+     * function, so the two paths cannot disagree. Which connector a
+     * provider is bound to is the integration layer's decision; it is not
+     * necessarily the connector that is current when the request runs.
+     */
+    private attributions;
     constructor(deps: EvmProviderRegistryDeps);
     get all(): readonly EIP6963ProviderDetail[];
     isTracked(provider: EIP1193Provider): boolean;
@@ -62,11 +80,25 @@ export declare class EvmProviderRegistry {
     };
     /** Add a discovered provider once. Returns false if already present. */
     add(detail: EIP6963ProviderDetail): boolean;
+    /**
+     * Record (or, with `undefined`, forget) the integration layer's own
+     * attribution resolver for a provider. See `attributions`.
+     */
+    rememberAttribution(provider: EIP1193Provider | undefined, resolve: (() => {
+        name: string;
+        rdns?: string;
+    } | undefined) | undefined): void;
+    /** The supplied attribution for a provider, if any resolves right now. */
+    private suppliedAttributionFor;
     /**
      * A provider's display name and rdns.
      *
-     * EIP-6963 metadata is authoritative when we have it; otherwise fall back to
-     * sniffing the injected provider, which is all a pre-6963 wallet offers.
+     * EIP-6963 metadata is authoritative when we have it. A supplied
+     * attribution (the connector a wagmi app connected through) comes next:
+     * it describes the SESSION, which is what the hook-driven events report.
+     * Otherwise fall back to sniffing the injected provider, which is all a
+     * pre-6963 wallet offers; a supplied name without an rdns keeps the
+     * sniffed rdns.
      */
     infoFor(provider: EIP1193Provider): {
         name: string;

package/dist/cjs/src/evm/EvmProviderRegistry.js

@@ -77,6 +77,24 @@ var EvmProviderRegistry = /** @class */ (function () {
         this.chainGenerations = new WeakMap();
         /** Listeners this SDK attached, so teardown can remove exactly those. */
         this.listeners = new Map();
+        /**
+         * Attribution supplied by the integration layer for a provider that was
+         * never announced: the wagmi fallback wrap names a connector's provider
+         * after the CONNECTOR, so request-derived events carry the same wallet
+         * name as the hook-driven events from the same connection. Without it
+         * the name came from flag sniffing, and a custom or embedded connector
+         * whose provider exposes no recognised flag split one wallet's activity
+         * between "Injected Provider" and the connector's name.
+         *
+         * A RESOLVER, read at each `infoFor`, not a value: the name is live for
+         * the connector the integration layer bound it to (a WalletConnect
+         * session that resolves or changes its peer renames without a re-wrap),
+         * and the integration layer names events on its hook path with the same
+         * function, so the two paths cannot disagree. Which connector a
+         * provider is bound to is the integration layer's decision; it is not
+         * necessarily the connector that is current when the request runs.
+         */
+        this.attributions = new WeakMap();
     }
     Object.defineProperty(EvmProviderRegistry.prototype, "all", {
         // ── the provider set ─────────────────────────────────────────────────────
@@ -135,19 +153,55 @@ var EvmProviderRegistry = /** @class */ (function () {
         this.seen.add(provider);
         return true;
     };
+    /**
+     * Record (or, with `undefined`, forget) the integration layer's own
+     * attribution resolver for a provider. See `attributions`.
+     */
+    EvmProviderRegistry.prototype.rememberAttribution = function (provider, resolve) {
+        if (!provider)
+            return;
+        if (!resolve) {
+            this.attributions.delete(provider);
+            return;
+        }
+        this.attributions.set(provider, resolve);
+    };
+    /** The supplied attribution for a provider, if any resolves right now. */
+    EvmProviderRegistry.prototype.suppliedAttributionFor = function (provider) {
+        var resolve = this.attributions.get(provider);
+        if (!resolve)
+            return undefined;
+        try {
+            var info = resolve();
+            return (info === null || info === void 0 ? void 0 : info.name) ? info : undefined;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    };
     /**
      * A provider's display name and rdns.
      *
-     * EIP-6963 metadata is authoritative when we have it; otherwise fall back to
-     * sniffing the injected provider, which is all a pre-6963 wallet offers.
+     * EIP-6963 metadata is authoritative when we have it. A supplied
+     * attribution (the connector a wagmi app connected through) comes next:
+     * it describes the SESSION, which is what the hook-driven events report.
+     * Otherwise fall back to sniffing the injected provider, which is all a
+     * pre-6963 wallet offers; a supplied name without an rdns keeps the
+     * sniffed rdns.
      */
     EvmProviderRegistry.prototype.infoFor = function (provider) {
         var announced = this.details.find(function (p) { return p.provider === provider; });
+        var supplied = announced
+            ? undefined
+            : this.suppliedAttributionFor(provider);
         var info = announced
             ? { name: announced.info.name, rdns: announced.info.rdns }
             : (function () {
+                var _a;
                 var injected = (0, provider_1.detectInjectedProviderInfo)(provider);
-                return { name: injected.name, rdns: injected.rdns };
+                return supplied
+                    ? { name: supplied.name, rdns: (_a = supplied.rdns) !== null && _a !== void 0 ? _a : injected.rdns }
+                    : { name: injected.name, rdns: injected.rdns };
             })();
         // WalletConnect names the TRANSPORT; the session's peer names the
         // wallet. Resolved live, per read: a session established after the
@@ -157,7 +211,10 @@ var EvmProviderRegistry = /** @class */ (function () {
         // is included because a flagless WalletConnect-compatible provider
         // registered BEFORE its session exists detects as nothing at all;
         // the peer appearing later is itself the proof of what it was, so
-        // the rdns upgrades with it.
+        // the rdns upgrades with it. A supplied name gets the same treatment
+        // and no more: the integration layer resolves its own peer names
+        // where it wants them, and a branded connector must keep its name on
+        // both paths.
         if (info.name === "WalletConnect" || info.name === "Injected Provider") {
             var peer = (0, provider_1.readWalletConnectPeer)(provider);
             if (peer === null || peer === void 0 ? void 0 : peer.name) {

package/dist/cjs/src/evm/EvmRequestTracker.d.ts

@@ -57,6 +57,18 @@ export declare class EvmRequestTracker {
      * never retry it, and every signature and transaction from that wallet
      * would be missed for the rest of the session.
      */
+    /** Monotonic creation stamp; owner precedence is decided by it. */
+    private static nextCreationSeq;
+    readonly creationSeq: number;
+    /**
+     * Put this tracker into an owner list at its CREATION-ORDER position.
+     * Registration can arrive out of order - an older instance's async wrap
+     * kick may resolve after a newer instance's - and dispatch picks from
+     * the END of the list, so append-on-registration would let resolution
+     * order decide which instance owns capture. Creation order is what the
+     * newest-live contract promises.
+     */
+    private insertBySeniority;
     registerRequestListeners(provider: EIP1193Provider): boolean;
     /** Install the wrapper function onto the provider; separated so the
      * routing shim above stays small. */
@@ -71,10 +83,15 @@ export declare class EvmRequestTracker {
     /**
      * Wallet attribution for request-derived events.
      *
-     * Live per read through the registry, so a WalletConnect session names
-     * its actual signer ("MetaMask Wallet", "Ledger Live") - the live-test
-     * rows had provider_name EMPTY on every signature and transaction, which
-     * made per-wallet activity unanswerable in the warehouse.
+     * Resolved through the registry at the START of each request and held
+     * for that request's whole lifecycle, receipt included. Reading it per
+     * status let a connector switch (two connectors sharing one provider) or
+     * a session change made while a prompt was open split one operation
+     * between two wallet names. Still live across requests: a WalletConnect
+     * session names its actual signer ("MetaMask Wallet", "Ledger Live") -
+     * the live-test rows had provider_name EMPTY on every signature and
+     * transaction, which made per-wallet activity unanswerable in the
+     * warehouse.
      */
     private attributionFor;
     private buildSignatureEventPayload;

package/dist/cjs/src/evm/EvmRequestTracker.js

@@ -140,6 +140,7 @@ var EvmRequestTracker = /** @class */ (function () {
         this.disposed = false;
         /** Providers whose owner list includes this instance; pruned on cleanup. */
         this.wrappedProviders = new Set();
+        this.creationSeq = EvmRequestTracker.nextCreationSeq++;
     }
     /** Stop every poll in flight. Terminal, like the event queue's close(). */
     EvmRequestTracker.prototype.cleanup = function () {
@@ -173,11 +174,24 @@ var EvmRequestTracker = /** @class */ (function () {
         this.polls.add(timer);
     };
     /**
-     * Wrap a provider's `request`. Returns whether the wrapper is installed:
-     * a caller that marks the provider as tracked on a false return would
-     * never retry it, and every signature and transaction from that wallet
-     * would be missed for the rest of the session.
+     * Put this tracker into an owner list at its CREATION-ORDER position.
+     * Registration can arrive out of order - an older instance's async wrap
+     * kick may resolve after a newer instance's - and dispatch picks from
+     * the END of the list, so append-on-registration would let resolution
+     * order decide which instance owns capture. Creation order is what the
+     * newest-live contract promises.
      */
+    EvmRequestTracker.prototype.insertBySeniority = function (owners) {
+        var _this = this;
+        var idx = owners.indexOf(this);
+        if (idx !== -1)
+            owners.splice(idx, 1);
+        var insertAt = owners.findIndex(function (o) { return o.creationSeq > _this.creationSeq; });
+        if (insertAt === -1)
+            owners.push(this);
+        else
+            owners.splice(insertAt, 0, this);
+    };
     EvmRequestTracker.prototype.registerRequestListeners = function (provider) {
         var _this = this;
         logger_1.logger.info("registerRequestListeners");
@@ -199,10 +213,7 @@ var EvmRequestTracker = /** @class */ (function () {
                 logger_1.logger.warn("wrapped without owner list; cannot rebind");
                 return false;
             }
-            var idx = owners.indexOf(this);
-            if (idx !== -1)
-                owners.splice(idx, 1);
-            owners.push(this);
+            this.insertBySeniority(owners);
             this.wrappedProviders.add(provider);
             logger_1.logger.info("Provider already wrapped; rebinding the wrapper to this instance.");
             return true;
@@ -243,10 +254,7 @@ var EvmRequestTracker = /** @class */ (function () {
             var slot = provider;
             var prior = slot[types_1.WRAPPED_REQUEST_OWNER_SYMBOL];
             var owners = Array.isArray(prior) ? prior : [];
-            var idx = owners.indexOf(this);
-            if (idx !== -1)
-                owners.splice(idx, 1);
-            owners.push(this);
+            this.insertBySeniority(owners);
             if (!Array.isArray(prior)) {
                 slot[types_1.WRAPPED_REQUEST_OWNER_SYMBOL] = owners;
             }
@@ -291,7 +299,7 @@ var EvmRequestTracker = /** @class */ (function () {
      */
     EvmRequestTracker.prototype.dispatchWrappedRequest = function (_a, provider_2, request_1) {
         return __awaiter(this, arguments, void 0, function (_b, provider, request) {
-            var generation_1, responsePromise, capturedChainId_1, response_1, error_1, rpcError, txPromise, txChainId_1, transactionHash_1, error_2, rpcError;
+            var generation_1, responsePromise, capturedChainId_1, attribution_1, response_1, error_1, rpcError, txPromise, txChainId_1, attribution_2, transactionHash_1, error_2, rpcError;
             var _this = this;
             var _c, _d, _e, _f;
             var method = _b.method, params = _b.params;
@@ -334,6 +342,7 @@ var EvmRequestTracker = /** @class */ (function () {
                         // below is never reported as unhandled. The real handling is there.
                         responsePromise.catch(function () { return undefined; });
                         capturedChainId_1 = this.registry.resolveChainId(provider);
+                        attribution_1 = this.attributionFor(provider);
                         // Fire-and-forget tracking
                         (function () { return __awaiter(_this, void 0, void 0, function () {
                             var e_1;
@@ -341,7 +350,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                 switch (_a.label) {
                                     case 0:
                                         _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.deps.signature(__assign({ status: types_1.SignatureStatus.REQUESTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)), this.attributionFor(provider))];
+                                        return [4 /*yield*/, this.deps.signature(__assign({ status: types_1.SignatureStatus.REQUESTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)), attribution_1)];
                                     case 1:
                                         _a.sent();
                                         return [3 /*break*/, 3];
@@ -367,7 +376,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                     switch (_a.label) {
                                         case 0:
                                             _a.trys.push([0, 2, , 3]);
-                                            return [4 /*yield*/, this.deps.signature(__assign({ status: types_1.SignatureStatus.CONFIRMED }, this.buildSignatureEventPayload(method, params, response_1, capturedChainId_1, provider)), this.attributionFor(provider))];
+                                            return [4 /*yield*/, this.deps.signature(__assign({ status: types_1.SignatureStatus.CONFIRMED }, this.buildSignatureEventPayload(method, params, response_1, capturedChainId_1, provider)), attribution_1)];
                                         case 1:
                                             _a.sent();
                                             return [3 /*break*/, 3];
@@ -392,7 +401,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                     switch (_a.label) {
                                         case 0:
                                             _a.trys.push([0, 2, , 3]);
-                                            return [4 /*yield*/, this.deps.signature(__assign({ status: types_1.SignatureStatus.REJECTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)), this.attributionFor(provider))];
+                                            return [4 /*yield*/, this.deps.signature(__assign({ status: types_1.SignatureStatus.REJECTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)), attribution_1)];
                                         case 1:
                                             _a.sent();
                                             return [3 /*break*/, 3];
@@ -431,6 +440,7 @@ var EvmRequestTracker = /** @class */ (function () {
                         txPromise = request({ method: method, params: params });
                         txPromise.catch(function () { return undefined; });
                         txChainId_1 = this.registry.resolveChainId(provider);
+                        attribution_2 = this.attributionFor(provider);
                         (function () { return __awaiter(_this, void 0, void 0, function () {
                             var payload, e_4;
                             return __generator(this, function (_a) {
@@ -440,7 +450,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                         return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
                                     case 1:
                                         payload = _a.sent();
-                                        return [4 /*yield*/, this.deps.transaction(__assign({ status: types_1.TransactionStatus.STARTED }, payload), this.attributionFor(provider))];
+                                        return [4 /*yield*/, this.deps.transaction(__assign({ status: types_1.TransactionStatus.STARTED }, payload), attribution_2)];
                                     case 2:
                                         _a.sent();
                                         return [3 /*break*/, 4];
@@ -467,11 +477,11 @@ var EvmRequestTracker = /** @class */ (function () {
                                         return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
                                     case 1:
                                         payload = _a.sent();
-                                        return [4 /*yield*/, this.deps.transaction(__assign(__assign({ status: types_1.TransactionStatus.BROADCASTED }, payload), { transactionHash: transactionHash_1 }), this.attributionFor(provider))];
+                                        return [4 /*yield*/, this.deps.transaction(__assign(__assign({ status: types_1.TransactionStatus.BROADCASTED }, payload), { transactionHash: transactionHash_1 }), attribution_2)];
                                     case 2:
                                         _a.sent();
                                         // Start async polling for transaction receipt
-                                        this.pollTransactionReceipt(provider, transactionHash_1, payload);
+                                        this.pollTransactionReceipt(provider, transactionHash_1, payload, attribution_2);
                                         return [3 /*break*/, 4];
                                     case 3:
                                         e_5 = _a.sent();
@@ -496,7 +506,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                             return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
                                         case 1:
                                             payload = _a.sent();
-                                            return [4 /*yield*/, this.deps.transaction(__assign({ status: types_1.TransactionStatus.REJECTED }, payload), this.attributionFor(provider))];
+                                            return [4 /*yield*/, this.deps.transaction(__assign({ status: types_1.TransactionStatus.REJECTED }, payload), attribution_2)];
                                         case 2:
                                             _a.sent();
                                             return [3 /*break*/, 4];
@@ -518,10 +528,15 @@ var EvmRequestTracker = /** @class */ (function () {
     /**
      * Wallet attribution for request-derived events.
      *
-     * Live per read through the registry, so a WalletConnect session names
-     * its actual signer ("MetaMask Wallet", "Ledger Live") - the live-test
-     * rows had provider_name EMPTY on every signature and transaction, which
-     * made per-wallet activity unanswerable in the warehouse.
+     * Resolved through the registry at the START of each request and held
+     * for that request's whole lifecycle, receipt included. Reading it per
+     * status let a connector switch (two connectors sharing one provider) or
+     * a session change made while a prompt was open split one operation
+     * between two wallet names. Still live across requests: a WalletConnect
+     * session names its actual signer ("MetaMask Wallet", "Ledger Live") -
+     * the live-test rows had provider_name EMPTY on every signature and
+     * transaction, which made per-wallet activity unanswerable in the
+     * warehouse.
      */
     EvmRequestTracker.prototype.attributionFor = function (provider) {
         var info = this.registry.infoFor(provider);
@@ -591,8 +606,11 @@ var EvmRequestTracker = /** @class */ (function () {
     /**
      * Polls for transaction receipt and emits tx.status = CONFIRMED or REVERTED.
      */
-    EvmRequestTracker.prototype.pollTransactionReceipt = function (provider_2, transactionHash_2, payload_1) {
-        return __awaiter(this, arguments, void 0, function (provider, transactionHash, payload, maxAttempts, intervalMs) {
+    EvmRequestTracker.prototype.pollTransactionReceipt = function (provider_2, transactionHash_2, payload_1, attribution_3) {
+        return __awaiter(this, arguments, void 0, function (provider, transactionHash, payload, 
+        // Snapshot from the broadcast: a connector or session change during
+        // the poll window must not relabel the receipt.
+        attribution, maxAttempts, intervalMs) {
             var attempts, poll;
             var _this = this;
             if (maxAttempts === void 0) { maxAttempts = 10; }
@@ -621,7 +639,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                     // status: 1 = success, 0 = reverted
                                     if (receipt.status === "0x1" || receipt.status === 1) {
                                         this.deps
-                                            .transaction(__assign(__assign({ status: types_1.TransactionStatus.CONFIRMED }, payload), { transactionHash: transactionHash }), this.attributionFor(provider))
+                                            .transaction(__assign(__assign({ status: types_1.TransactionStatus.CONFIRMED }, payload), { transactionHash: transactionHash }), attribution)
                                             .catch(function (e) {
                                             return logger_1.logger.error("Formo: Failed to track transaction confirmation", e);
                                         });
@@ -629,7 +647,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                     }
                                     else if (receipt.status === "0x0" || receipt.status === 0) {
                                         this.deps
-                                            .transaction(__assign(__assign({ status: types_1.TransactionStatus.REVERTED }, payload), { transactionHash: transactionHash }), this.attributionFor(provider))
+                                            .transaction(__assign(__assign({ status: types_1.TransactionStatus.REVERTED }, payload), { transactionHash: transactionHash }), attribution)
                                             .catch(function (e) {
                                             return logger_1.logger.error("Formo: Failed to track transaction revert", e);
                                         });
@@ -851,6 +869,14 @@ var EvmRequestTracker = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Wrap a provider's `request`. Returns whether the wrapper is installed:
+     * a caller that marks the provider as tracked on a false return would
+     * never retry it, and every signature and transaction from that wallet
+     * would be missed for the rest of the session.
+     */
+    /** Monotonic creation stamp; owner precedence is decided by it. */
+    EvmRequestTracker.nextCreationSeq = 0;
     return EvmRequestTracker;
 }());
 exports.EvmRequestTracker = EvmRequestTracker;

package/dist/cjs/src/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.38.0";
+export declare const version = "1.38.2";
 //# sourceMappingURL=version.d.ts.map

package/dist/cjs/src/version.js

@@ -3,5 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // This file is auto-generated by scripts/update-version.js during npm version
 // Do not edit manually - it will be overwritten
-exports.version = '1.38.0';
+exports.version = '1.38.2';
 //# sourceMappingURL=version.js.map

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

@@ -6,7 +6,7 @@
  * wrapping approach when Wagmi mode is enabled.
  */
 import { FormoAnalytics } from "../FormoAnalytics";
-import { WagmiConfig, QueryClient } from "./types";
+import { QueryClient, WagmiConfig } from "./types";
 /**
  * How long the markers stay trustworthy after the last handler goes away.
  *
@@ -337,6 +337,35 @@ export declare class WagmiEventHandler {
      * (still connected through its own connector).
      */
     private isAddressConnected;
+    /**
+     * A specific connector's name and rdns, for the fallback-wrapped
+     * provider's request-derived events.
+     *
+     * The NAME is exactly what the hook path emits for that connector
+     * (`getConnectorName`: the live WalletConnect peer for a WalletConnect
+     * connector, the connector's own name otherwise), so a branded connector
+     * keeps its name on both paths and a session that changes wallets
+     * renames on both. The rdns is the connector's when wagmi knows it as
+     * ONE value (EIP-6963 discovered connectors carry theirs, some as a
+     * one-element list); a connector that matches several rdns values does
+     * not say which one this provider is, so nothing is passed and the
+     * registry keeps the sniffed one.
+     */
+    private attributionForConnector;
+    /**
+     * Resolver handed to the registry at wrap time, read at each request
+     * start. BOUND to the connector whose `getProvider` resolved to the
+     * wrapped provider, not to whichever connector is current: an app can
+     * keep a wallet client over a previous connector's provider and issue a
+     * request through it after switching, and that request belongs to the
+     * wallet that handles it. The peer name is still read live. A provider
+     * SHARED by two connectors is re-bound when the new connector's
+     * resolution lands (one microtask for an injected connector); a request
+     * issued inside that gap keeps the previous label.
+     */
+    private boundConnectorAttribution;
+    /** `getConnectorName` for a SPECIFIC connector, current or not. */
+    private nameForConnector;
     /**
      * Get the connector name from Wagmi state
      */
@@ -362,6 +391,43 @@ export declare class WagmiEventHandler {
      * dedup. Fire-and-forget per connection; a provider that cannot be
      * produced simply keeps mutation-only capture.
      */
+    /**
+     * Connections THIS instance has wrapped. Deliberately per-instance, not
+     * module-level: a module-level guard let a rebuilt SDK instance skip
+     * re-wrapping, so ownership stayed with the torn-down instance and every
+     * capture died in its closed queue - and it also stopped a second
+     * write-key instance from ever registering. Re-wrapping is safe and
+     * cheap: the request tracker rebinds ownership of an intact wrapper.
+     */
+    /**
+     * Latest wrap attempt per connector. Every kick re-resolves
+     * getProvider() - a connector can hand out a REPLACEMENT provider after
+     * a reconnect, so a once-only guard would leave the new session's
+     * provider unwrapped forever. Re-wrapping is idempotent: the request
+     * tracker rebinds ownership of an intact wrapper. The epoch lets a slow
+     * resolution from a superseded kick (an earlier session, an earlier
+     * chain) be discarded instead of overwriting fresher state.
+     */
+    private wrapEpochs;
+    /** Consecutive automatic wrap retries per connector; see below. */
+    private wrapRetryCounts;
+    /** Pending retry timers, cancelled by cleanup(). */
+    private wrapRetryTimers;
+    /**
+     * Bumped on every observed disconnect. Every wrap attempt captures it
+     * at kick time and its resolution stands down on a mismatch, so a
+     * disconnect invalidates ALL pending wraps at once - including ones
+     * whose getProvider() had not resolved yet, which no per-connector
+     * bookkeeping can reach because nothing has been recorded for them.
+     */
+    private wrapSessionGeneration;
+    /** The active connector this instance wrapped, and its provider, for
+     * chain updates. Kept as a pair so a chain report is only ever applied
+     * to the provider of the connector it describes. Keyed by connector,
+     * not by connection record: wagmi REPLACES the connection object on
+     * every account or chain update, so record identity is not stable. */
+    private fallbackConnector?;
+    private fallbackProvider?;
     private wrapActiveConnectorProvider;
     private kickWalletConnectPeerLookup;
     /**