@formo/analytics 1.37.0 → 1.38.1

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

@@ -58,6 +58,7 @@ exports.WagmiEventHandler = exports.MARKER_GRACE_MS = void 0;
 exports.__resetSeededWallet = __resetSeededWallet;
 var events_1 = require("../types/events");
 var logger_1 = require("../logger");
+var provider_1 = require("../provider");
 var batch_1 = require("../evm/batch");
 var utils_1 = require("./utils");
 /**
@@ -201,25 +202,46 @@ var ownerKey = function (writeKey, config) {
     }
     return "".concat(writeKey, ":").concat(id);
 };
+// User-rejection detection is shared with the EIP-1193 path (4001, the
+// WalletConnect 5000-family, and viem's typed error): see
+// provider/detection.ts for the dialects and why 4001 alone missed every
+// WalletConnect rejection.
+var isUserRejection = provider_1.isUserRejectionError;
 /**
- * Was this mutation error the user dismissing the wallet prompt?
+ * Real wallet names behind WalletConnect connectors, resolved lazily.
  *
- * Matches the EIP-1193 path's rule (code 4001), but a wagmi mutation error
- * arrives wrapped: viem nests the RPC error under `cause`, sometimes twice.
- * Walk the chain rather than trusting the top level, and accept viem's
- * `UserRejectedRequestError` by name for wallets that map the rejection to a
- * typed error without preserving the numeric code.
+ * WalletConnect is a transport: the signing wallet (Ledger Live, MetaMask
+ * Mobile, Safe, ...) names itself in the session's peer metadata, reachable
+ * only through the connector's async `getProvider()`. Connect emission is
+ * deliberately synchronous (see the marker comments below), so the lookup
+ * can never be awaited in line - it is kicked fire-and-forget the first
+ * time a WalletConnect connector is seen, and every event after resolution
+ * carries the real wallet's name. The first connect may still say
+ * "WalletConnect"; that is the honest state at that instant.
+ *
+ * HONEST STATUS: with the new-connection invalidation below, no event the
+ * wagmi path emits TODAY observably carries the resolved name - connects
+ * fire before resolution and rebuilds suppress re-emission. The cache
+ * exists for the attribution work (wallet names on signature and
+ * transaction events), which fires mid-session, after resolution.
+ *
+ * Names are keyed by the CONNECTOR (stable across a page's sessions) so
+ * they actually serve reads; lookups are guarded per CONNECTION (wagmi
+ * replaces the connection object per session), so every new session
+ * re-resolves and OVERWRITES the name. A reconnect through the same
+ * connector to a different wallet can therefore mislabel at most the one
+ * event that fires between the new session's start and its resolution -
+ * one microtask for an initialised connector - and self-corrects. The
+ * alternative, keying names by connection, was tried and kept the name
+ * from ever surfacing: the only reader that fires per session runs before
+ * any lookup can resolve. WeakMaps, so nothing outlives its object.
  */
-function isUserRejection(error) {
-    var cursor = error;
-    for (var depth = 0; cursor && depth < 5; depth++) {
-        if (cursor.code === 4001 || cursor.name === "UserRejectedRequestError") {
-            return true;
-        }
-        cursor = cursor.cause;
-    }
-    return false;
-}
+var walletConnectPeerNames = new WeakMap();
+var walletConnectPeerLookups = new WeakSet();
+/** The connection whose lookup may write the connector's name: always the
+ * newest kicked one, so a slow resolution from a PREVIOUS session cannot
+ * land after the current session's and overwrite it. */
+var walletConnectPeerLatest = new WeakMap();
 /**
  * Pending transactions, shared per destination rather than per handler.
  *
@@ -404,6 +426,57 @@ var WagmiEventHandler = /** @class */ (function () {
          * Key format: `${queryHash}:${status}`
          */
         this.processedQueries = new Set();
+        /**
+         * Start resolving the wallet behind a WalletConnect connection.
+         *
+         * Fire-and-forget on purpose: emission paths are synchronous by design
+         * and must never wait (see the connect marker comment). Called at the
+         * START of the status/address flows rather than only at read time - the
+         * lookup is one microtask for an initialised connector, and the emission
+         * sits behind several awaits, so kicking early usually means even the
+         * FIRST connect names the real wallet. When the race is lost the event
+         * honestly says "WalletConnect" and every later event names the peer.
+         */
+        /**
+         * Install the request wrapper on the active connector's provider.
+         *
+         * This is what lets wagmi mode capture IMPERATIVE viem calls
+         * (walletClient.sendTransaction / .signMessage / .writeContract / raw
+         * request), which create no mutation and were silently lost. Hook-driven
+         * calls stay owned by the mutation handlers via the pending-mutation
+         * dedup. Fire-and-forget per connection; a provider that cannot be
+         * produced simply keeps mutation-only capture.
+         */
+        /**
+         * Connections THIS instance has wrapped. Deliberately per-instance, not
+         * module-level: a module-level guard let a rebuilt SDK instance skip
+         * re-wrapping, so ownership stayed with the torn-down instance and every
+         * capture died in its closed queue - and it also stopped a second
+         * write-key instance from ever registering. Re-wrapping is safe and
+         * cheap: the request tracker rebinds ownership of an intact wrapper.
+         */
+        /**
+         * Latest wrap attempt per connector. Every kick re-resolves
+         * getProvider() - a connector can hand out a REPLACEMENT provider after
+         * a reconnect, so a once-only guard would leave the new session's
+         * provider unwrapped forever. Re-wrapping is idempotent: the request
+         * tracker rebinds ownership of an intact wrapper. The epoch lets a slow
+         * resolution from a superseded kick (an earlier session, an earlier
+         * chain) be discarded instead of overwriting fresher state.
+         */
+        this.wrapEpochs = new WeakMap();
+        /** Consecutive automatic wrap retries per connector; see below. */
+        this.wrapRetryCounts = new WeakMap();
+        /** Pending retry timers, cancelled by cleanup(). */
+        this.wrapRetryTimers = new Set();
+        /**
+         * Bumped on every observed disconnect. Every wrap attempt captures it
+         * at kick time and its resolution stands down on a mismatch, so a
+         * disconnect invalidates ALL pending wraps at once - including ones
+         * whose getProvider() had not resolved yet, which no per-connector
+         * bookkeeping can reach because nothing has been recorded for them.
+         */
+        this.wrapSessionGeneration = 0;
         this.formo = formoAnalytics;
         this.wagmiConfig = wagmiConfig;
         this.queryClient = queryClient;
@@ -578,6 +651,10 @@ var WagmiEventHandler = /** @class */ (function () {
         var connectionUnsubscribe = this.wagmiConfig.subscribe(function (state) { var _a, _b; return "".concat((_a = state.current) !== null && _a !== void 0 ? _a : "", "|").concat((_b = _this.getConnectedAddress(state)) !== null && _b !== void 0 ? _b : ""); }, function (key, prevKey) {
             var _a = key.split("|"), address = _a[1];
             var _b = (prevKey !== null && prevKey !== void 0 ? prevKey : "|").split("|"), prevAddress = _b[1];
+            // A connector switch keeps status "connected", so the status
+            // subscription never re-wraps; the NEW active connection's provider
+            // must be instrumented from here or its imperative calls are lost.
+            _this.wrapActiveConnectorProvider(_this.getState());
             _this.handleActiveAddressChange(address || undefined, prevAddress || undefined);
         });
         this.unsubscribers.push(connectionUnsubscribe);
@@ -615,6 +692,17 @@ var WagmiEventHandler = /** @class */ (function () {
      */
     WagmiEventHandler.prototype.seedFromCurrentState = function () {
         var _a, _b;
+        // Fire-and-forget here: the seed is synchronous by design, so its own
+        // connect may carry the generic name; the status flow awaits instead.
+        // A throwing store must not break construction.
+        try {
+            var snapshot = this.getState();
+            this.kickWalletConnectPeerLookup(snapshot);
+            this.wrapActiveConnectorProvider(snapshot);
+        }
+        catch (_c) {
+            /* the seed continues; names fall back to the connector's own */
+        }
         try {
             var state = this.getState();
             if (state.status !== "connected") {
@@ -867,11 +955,24 @@ var WagmiEventHandler = /** @class */ (function () {
      */
     WagmiEventHandler.prototype.handleStatusChange = function (status, prevStatus) {
         return __awaiter(this, void 0, void 0, function () {
-            var state, address, chainId, disconnectedAddress, disconnectedChainId, walletKey, connection, connectorName, error_1, error_2;
+            var snapshot, 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:
+                        if (status === "disconnected" || status === "reconnecting") {
+                            // The wrapped session is over - or, for "reconnecting", about to be
+                            // replaced without ever passing through "disconnected". This must
+                            // run for EVERY such transition, before the processing lock and
+                            // regardless of whether a wallet was being tracked, or a rapid
+                            // same-connector reconnect retains the old provider and the chain
+                            // callback writes the new session's chain onto it. The generation
+                            // bump invalidates every wrap still in flight from the ended
+                            // session, resolved or not. The "connected" that follows re-wraps.
+                            this.wrapSessionGeneration += 1;
+                            this.fallbackConnector = undefined;
+                            this.fallbackProvider = undefined;
+                        }
                         // Prevent concurrent processing
                         if (this.trackingState.isProcessing) {
                             // Dropped, not queued - but remember that a disconnect went past.
@@ -888,6 +989,18 @@ var WagmiEventHandler = /** @class */ (function () {
                             return [2 /*return*/];
                         }
                         this.trackingState.isProcessing = true;
+                        // Start resolving the wallet behind a WalletConnect session. NEVER
+                        // awaited: every path from a store signal to its emission is
+                        // synchronous by design, and an await here reorders transitions (it
+                        // demonstrably drops connects under rapid connect/disconnect cycles).
+                        try {
+                            snapshot = this.getState();
+                            this.kickWalletConnectPeerLookup(snapshot);
+                            this.wrapActiveConnectorProvider(snapshot);
+                        }
+                        catch (_f) {
+                            // A throwing store must not break the status flow.
+                        }
                         // 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
@@ -1155,6 +1268,16 @@ var WagmiEventHandler = /** @class */ (function () {
      * 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.handleActiveAddressChangeEntryKick = function () {
+        // An account switch replaces the connection object; kick a lookup for
+        // the new one so events that follow can name the wallet.
+        try {
+            this.kickWalletConnectPeerLookup(this.getState());
+        }
+        catch (_a) {
+            /* a throwing store must not break the flow */
+        }
+    };
     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;
@@ -1162,6 +1285,7 @@ var WagmiEventHandler = /** @class */ (function () {
             return __generator(this, function (_g) {
                 switch (_g.label) {
                     case 0:
+                        this.handleActiveAddressChangeEntryKick();
                         state = this.getState();
                         if (state.status !== "connected")
                             return [2 /*return*/];
@@ -1385,10 +1509,31 @@ var WagmiEventHandler = /** @class */ (function () {
      */
     WagmiEventHandler.prototype.handleChainChange = function (chainId, prevChainId) {
         return __awaiter(this, void 0, void 0, function () {
-            var state, address, hadAddress, wasAnnounced, announcedNow;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var live, activeConnector, state, address, hadAddress, wasAnnounced, announcedNow;
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
+                        // Keep the fallback-wrapped provider's registry chain in step with the
+                        // store, so request-derived events are labelled correctly even when the
+                        // provider exposes no synchronous chainId. Only when the report is
+                        // about the connection that provider belongs to: after a connector
+                        // switch the store's chain describes the NEW connection, and writing it
+                        // to the old provider would mislabel that wallet's events.
+                        if (this.fallbackProvider !== undefined) {
+                            live = this.getState();
+                            activeConnector = live.current
+                                ? (_a = live.connections.get(live.current)) === null || _a === void 0 ? void 0 : _a.connector
+                                : undefined;
+                            if (activeConnector === this.fallbackConnector) {
+                                try {
+                                    (_c = (_b = this.formo)._rememberWagmiProviderChain) === null || _c === void 0 ? void 0 : _c.call(_b, this.fallbackProvider, chainId);
+                                }
+                                catch (_e) {
+                                    /* never let bookkeeping break the chain flow */
+                                }
+                            }
+                        }
                         if (chainId === prevChainId || chainId === undefined) {
                             return [2 /*return*/];
                         }
@@ -1434,7 +1579,7 @@ var WagmiEventHandler = /** @class */ (function () {
                         });
                         return [4 /*yield*/, this.applyChainForTrackedWallet(address, chainId)];
                     case 1:
-                        _a.sent();
+                        _d.sent();
                         return [2 /*return*/];
                 }
             });
@@ -1632,11 +1777,9 @@ var WagmiEventHandler = /** @class */ (function () {
                     return;
                 _this.formo.transaction(__assign(__assign(__assign(__assign({ status: outcome, chainId: settledChainId_1 || 0, address: pending.address }, (call.data && { data: call.data })), (call.to && { to: call.to })), (call.value && { value: call.value })), ((receipt === null || receipt === void 0 ? void 0 : receipt.transactionHash)
                     ? { transactionHash: receipt.transactionHash }
-                    : {})), {
-                    batch_size: pending.calls.length,
-                    batch_index: index,
-                    batch_id: batchId,
-                });
+                    : {})), __assign({ batch_size: pending.calls.length, batch_index: index, batch_id: batchId }, (pending.providerName
+                    ? { providerName: pending.providerName }
+                    : {})));
             });
             // Settled; a later refetch of the same query must not re-emit.
             this.pendingBatches.delete(batchId);
@@ -1719,9 +1862,9 @@ var WagmiEventHandler = /** @class */ (function () {
                 chainId: chainId,
                 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)
-            pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.safeFunctionArgs);
+            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 })), __assign(__assign({}, ((pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.providerName)
+                ? { providerName: pendingTx.providerName }
+                : this.mutationAttribution())), pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.safeFunctionArgs));
             // Clean up the pending transaction after confirmation
             this.pendingTransactions.delete(normalizedHash);
         }
@@ -1787,6 +1930,76 @@ var WagmiEventHandler = /** @class */ (function () {
     /**
      * Handle signature mutations (signMessage, signTypedData)
      */
+    /**
+     * Is a PENDING wagmi mutation already covering this wallet request?
+     *
+     * The hybrid-capture dedup. TanStack dispatches `pending` BEFORE the
+     * mutationFn issues the wallet call (verified against query-core), so a
+     * hook-driven request always finds its mutation here and the request
+     * wrapper stands down; an imperative viem call never does, and the
+     * wrapper captures it. Matching is by mutation type, refined with cheap
+     * parameter checks where the shapes allow, and errs toward NOT skipping:
+     * a duplicate is visible and diagnosable, a silent loss is neither.
+     */
+    WagmiEventHandler.prototype.hasMatchingPendingMutation = function (method, params) {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+            var cache = (_a = this.queryClient) === null || _a === void 0 ? void 0 : _a.getMutationCache();
+            var mutations = (_b = cache === null || cache === void 0 ? void 0 : cache.getAll) === null || _b === void 0 ? void 0 : _b.call(cache);
+            if (!Array.isArray(mutations))
+                return false;
+            var wanted = {
+                personal_sign: ["signMessage"],
+                eth_signTypedData_v4: ["signTypedData"],
+                eth_sendTransaction: ["sendTransaction", "writeContract"],
+                wallet_sendCalls: ["sendCalls"],
+            };
+            var types = wanted[method];
+            if (!types)
+                return false;
+            for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {
+                var mutation = mutations_1[_i];
+                if (((_c = mutation === null || mutation === void 0 ? void 0 : mutation.state) === null || _c === void 0 ? void 0 : _c.status) !== "pending")
+                    continue;
+                var key = (_e = (_d = mutation === null || mutation === void 0 ? void 0 : mutation.options) === null || _d === void 0 ? void 0 : _d.mutationKey) === null || _e === void 0 ? void 0 : _e[0];
+                if (typeof key !== "string" || !types.includes(key))
+                    continue;
+                // Cheap refinements. On mismatch keep scanning; on no basis to
+                // compare, treat the type-level match as decisive.
+                var variables = (_f = mutation.state) === null || _f === void 0 ? void 0 : _f.variables;
+                if (key === "sendTransaction" && variables) {
+                    var req = (Array.isArray(params) ? params[0] : undefined);
+                    var mutTo = variables.to;
+                    if (typeof (req === null || req === void 0 ? void 0 : req.to) === "string" &&
+                        typeof mutTo === "string" &&
+                        req.to.toLowerCase() !== mutTo.toLowerCase()) {
+                        continue;
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+        catch (_g) {
+            return false;
+        }
+    };
+    /**
+     * Wallet attribution for mutation- and query-derived events.
+     *
+     * Mid-session events (signatures, transactions) fire after the peer
+     * lookup has resolved, so a WalletConnect connector names its actual
+     * signer here - the first observable consumer of the peer cache.
+     */
+    WagmiEventHandler.prototype.mutationAttribution = function () {
+        try {
+            var name_1 = this.getConnectorName(this.getState());
+            return name_1 ? { providerName: name_1 } : undefined;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    };
     WagmiEventHandler.prototype.handleSignatureMutation = function (mutationType, mutation) {
         var _a, _b, _c, _d;
         if (!this.formo.isAutocaptureEnabled("signature")) {
@@ -1847,7 +2060,7 @@ var WagmiEventHandler = /** @class */ (function () {
                 chainId: chainId,
                 address: address,
                 message: message,
-            });
+            }, this.mutationAttribution());
         }
         catch (error) {
             logger_1.logger.error("WagmiEventHandler: Error handling signature mutation:", error);
@@ -1857,7 +2070,7 @@ var WagmiEventHandler = /** @class */ (function () {
      * Handle transaction mutations (sendTransaction, writeContract)
      */
     WagmiEventHandler.prototype.handleTransactionMutation = function (mutationType, mutation) {
-        var _a;
+        var _a, _b;
         if (!this.formo.isAutocaptureEnabled("transaction")) {
             return;
         }
@@ -1948,7 +2161,7 @@ var WagmiEventHandler = /** @class */ (function () {
             // Include the sender address to handle wallet switches between broadcast and confirmation
             if (status_2 === events_1.TransactionStatus.BROADCASTED && transactionHash) {
                 var normalizedHash = transactionHash.toLowerCase();
-                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 }));
+                var txDetails = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ address: userAddress }, ((_b = this.mutationAttribution()) !== null && _b !== void 0 ? _b : {})), (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_1.logger.debug("WagmiEventHandler: Stored pending transaction for confirmation", {
                     transactionHash: normalizedHash,
@@ -1962,9 +2175,7 @@ var WagmiEventHandler = /** @class */ (function () {
                     }
                 }
             }
-            this.formo.transaction(__assign(__assign(__assign(__assign(__assign(__assign({ status: status_2, chainId: chainId || 0, address: userAddress }, (data && { data: data })), (to && { to: to })), (value && { value: value })), (transactionHash && { transactionHash: transactionHash })), (function_name && { function_name: function_name })), (function_args && { function_args: function_args })), 
-            // Spread function args as additional properties (only colliding keys are prefixed)
-            safeFunctionArgs);
+            this.formo.transaction(__assign(__assign(__assign(__assign(__assign(__assign({ status: status_2, chainId: chainId || 0, address: userAddress }, (data && { data: data })), (to && { to: to })), (value && { value: value })), (transactionHash && { transactionHash: transactionHash })), (function_name && { function_name: function_name })), (function_args && { function_args: function_args })), __assign(__assign({}, this.mutationAttribution()), safeFunctionArgs));
         }
         catch (error) {
             logger_1.logger.error("WagmiEventHandler: Error handling transaction mutation:", error);
@@ -2013,9 +2224,10 @@ var WagmiEventHandler = /** @class */ (function () {
                 value: (call === null || call === void 0 ? void 0 : call.value) !== undefined ? String(call.value) : undefined,
                 data: call === null || call === void 0 ? void 0 : call.data,
             }); });
+            var attribution_1 = this.mutationAttribution();
             var emitAll = function (status, extra) {
                 calls_1.forEach(function (call, index) {
-                    _this.formo.transaction(__assign(__assign(__assign({ status: status, chainId: chainId || 0, address: userAddress }, (call.data && { data: call.data })), (call.to && { to: call.to })), (call.value && { value: call.value })), __assign({ batch_size: calls_1.length, batch_index: index }, extra));
+                    _this.formo.transaction(__assign(__assign(__assign({ status: status, chainId: chainId || 0, address: userAddress }, (call.data && { data: call.data })), (call.to && { to: call.to })), (call.value && { value: call.value })), __assign(__assign({ batch_size: calls_1.length, batch_index: index }, attribution_1), extra));
                 });
             };
             if (state.status === "pending") {
@@ -2029,7 +2241,7 @@ var WagmiEventHandler = /** @class */ (function () {
                 logger_1.logger.debug("WagmiEventHandler: sendCalls broadcast", { batchId: batchId });
                 emitAll(events_1.TransactionStatus.BROADCASTED, batchId ? { batch_id: batchId } : undefined);
                 if (batchId) {
-                    this.pendingBatches.set(batchId, __assign(__assign({ address: userAddress }, (chainId !== undefined && { chainId: chainId })), { chainIdWasExplicit: explicitChainId !== undefined, calls: calls_1 }));
+                    this.pendingBatches.set(batchId, __assign(__assign(__assign({ address: userAddress }, (attribution_1 !== null && attribution_1 !== void 0 ? attribution_1 : {})), (chainId !== undefined && { chainId: chainId })), { chainIdWasExplicit: explicitChainId !== undefined, calls: calls_1 }));
                     // Same bound as pendingTransactions, same reason.
                     if (this.pendingBatches.size > 100) {
                         var keys = Array.from(this.pendingBatches.keys());
@@ -2133,12 +2345,240 @@ var WagmiEventHandler = /** @class */ (function () {
             return undefined;
         }
         var connection = state.connections.get(state.current);
-        return connection === null || connection === void 0 ? void 0 : connection.connector.name;
+        var connector = connection === null || connection === void 0 ? void 0 : connection.connector;
+        if (!connection || !connector) {
+            return undefined;
+        }
+        var cached = walletConnectPeerNames.get(connector);
+        if (cached) {
+            return cached;
+        }
+        // Backstop kick; the flow entry points kick earlier so the lookup has
+        // usually resolved by the time an emission reads the name.
+        this.kickWalletConnectPeerLookup(state);
+        return connector.name;
+    };
+    WagmiEventHandler.prototype.wrapActiveConnectorProvider = function (state, isRetry) {
+        var _this = this;
+        var _a, _b, _c;
+        if (isRetry === void 0) { isRetry = false; }
+        // OPT-IN only. Wagmi mode's baseline never touches the signing
+        // transport; instrumenting the provider is an explicit integrator
+        // decision (options.wagmi.eip1193Fallback), made auditable in
+        // configuration rather than implied by a version bump.
+        var optedIn = ((_b = (_a = this.formo.options) === null || _a === void 0 ? void 0 : _a.wagmi) === null || _b === void 0 ? void 0 : _b.eip1193Fallback) === true;
+        if (!optedIn) {
+            return;
+        }
+        if (state.status !== "connected") {
+            // Status kicks run for every transition; only a connected snapshot
+            // describes a session worth wrapping.
+            return;
+        }
+        var connection = state.current
+            ? state.connections.get(state.current)
+            : undefined;
+        var connector = connection === null || connection === void 0 ? void 0 : connection.connector;
+        if (!connection || typeof (connector === null || connector === void 0 ? void 0 : connector.getProvider) !== "function") {
+            return;
+        }
+        var epoch = ((_c = this.wrapEpochs.get(connector)) !== null && _c !== void 0 ? _c : 0) + 1;
+        this.wrapEpochs.set(connector, epoch);
+        var session = this.wrapSessionGeneration;
+        // A store-driven kick resets the retry budget; automatic retries
+        // (below) spend it.
+        if (!isRetry) {
+            this.wrapRetryCounts.delete(connector);
+        }
+        // When the NEWEST attempt fails, older in-flight resolutions have
+        // been epoch-discarded (they may describe an earlier session) and
+        // nothing else would wrap the provider until the next store update.
+        // Recover by re-kicking fresh with live state, bounded so a
+        // persistently failing connector cannot loop: after the budget is
+        // spent, recovery waits for a real store update, which resets it.
+        var retryAfterFailure = function () {
+            var _a;
+            if (_this.disposed)
+                return;
+            if (_this.wrapEpochs.get(connector) !== epoch) {
+                // Superseded: the newer attempt owns recovery.
+                return;
+            }
+            var failures = ((_a = _this.wrapRetryCounts.get(connector)) !== null && _a !== void 0 ? _a : 0) + 1;
+            _this.wrapRetryCounts.set(connector, failures);
+            if (failures > 3)
+                return;
+            var timer = setTimeout(function () {
+                var _a;
+                _this.wrapRetryTimers.delete(timer);
+                if (_this.disposed)
+                    return;
+                // Re-kick only while THIS connector is still the active one and
+                // no newer attempt superseded this one. A retry for a connector
+                // the user has left must not fire at the current connector: with
+                // the retry flag it would skip the budget reset and, worse, its
+                // fresh epoch would discard the current connector's own in-flight
+                // resolution.
+                var live = _this.getState();
+                var stillCurrent = live.current !== undefined &&
+                    ((_a = live.connections.get(live.current)) === null || _a === void 0 ? void 0 : _a.connector) === connector;
+                if (stillCurrent && _this.wrapEpochs.get(connector) === epoch) {
+                    _this.wrapActiveConnectorProvider(live, true);
+                }
+            }, 25 * failures);
+            _this.wrapRetryTimers.add(timer);
+        };
+        var resolution;
+        try {
+            resolution = connector.getProvider();
+        }
+        catch (_d) {
+            // A synchronous throw must not escape into the subscription
+            // callback: address-change handling runs after this kick and a
+            // propagated throw would silently skip it.
+            retryAfterFailure();
+            return;
+        }
+        resolution
+            .then(function (provider) {
+            var _a, _b, _c, _d;
+            if (_this.wrapEpochs.get(connector) !== epoch) {
+                // A newer kick is in flight or already resolved; this answer may
+                // describe an earlier session. Let the newest one win.
+                return;
+            }
+            // The fallback installs only the request wrapper, so a provider
+            // without a synchronous chainId property would never teach the
+            // registry its chain and its events would carry chain 0. The wagmi
+            // store knows; feed it here and on every later chain change. Read
+            // the chain from LIVE state, not from a snapshot taken before this
+            // asynchronous resolution: a switch that lands while getProvider is
+            // in flight fires handleChainChange before fallbackProvider exists,
+            // so a pre-resolution snapshot would stick as the recorded chain.
+            // Activity is judged by CONNECTOR identity: wagmi replaces the
+            // connection record itself on every account or chain update.
+            var live = _this.getState();
+            // A wrap only describes a CONNECTED session. Status changes kick
+            // this path for every transition, and a resolution landing while
+            // disconnected would re-point the fallback pair at a provider
+            // whose session is over.
+            var stillActive = !_this.disposed &&
+                _this.wrapSessionGeneration === session &&
+                live.status === "connected" &&
+                live.current !== undefined &&
+                ((_a = live.connections.get(live.current)) === null || _a === void 0 ? void 0 : _a.connector) === connector;
+            if (!stillActive) {
+                // The user moved on while getProvider was in flight. Wrapping
+                // now would instrument a provider whose chain nobody feeds -
+                // its requests would report chain 0. Switching back re-kicks.
+                return;
+            }
+            var chainId = (_b = _this.getActiveConnectionChainId(live)) !== null && _b !== void 0 ? _b : live.chainId;
+            var wrapped = (_d = (_c = _this.formo)._wrapWagmiProvider) === null || _d === void 0 ? void 0 : _d.call(_c, provider, typeof chainId === "number" ? chainId : undefined);
+            if (wrapped !== true) {
+                // The provider was refused (invalid shape, frozen provider,
+                // torn-down SDK).
+                retryAfterFailure();
+                return;
+            }
+            _this.wrapRetryCounts.delete(connector);
+            _this.fallbackConnector = connector;
+            _this.fallbackProvider = provider;
+        })
+            .catch(function () {
+            // Mutation-only capture remains.
+            retryAfterFailure();
+        });
+    };
+    WagmiEventHandler.prototype.kickWalletConnectPeerLookup = function (state) {
+        var _a, _b;
+        var connection = state.current
+            ? state.connections.get(state.current)
+            : undefined;
+        var connector = connection === null || connection === void 0 ? void 0 : connection.connector;
+        if (!connection ||
+            !connector ||
+            typeof connector.name !== "string" ||
+            !/walletconnect/i.test(connector.name) ||
+            typeof connector.getProvider !== "function" ||
+            walletConnectPeerLookups.has(connection)) {
+            return;
+        }
+        walletConnectPeerLookups.add(connection);
+        // A NEW connection invalidates the cached name SYNCHRONOUSLY. The
+        // connect flow reads the cache in the same tick it kicks the lookup,
+        // so retaining the previous session's name here deterministically
+        // attributed a reconnect-to-a-different-wallet to the OLD wallet.
+        // Wrong is worse than generic: the new session's connect now says
+        // "WalletConnect" and the resolved peer serves the session's LATER
+        // events (signatures, transactions - the attribution work) instead.
+        // A rebuild over the SAME connection does not re-kick (guard above),
+        // so it keeps its already-proven name.
+        if (walletConnectPeerLatest.get(connector) !== connection) {
+            walletConnectPeerNames.delete(connector);
+        }
+        walletConnectPeerLatest.set(connector, connection);
+        var settled = false;
+        // A cached name from a PREVIOUS session is unproven for this one. It
+        // keeps serving only until this session's lookup settles or the grace
+        // timer fires - whichever ends the uncertainty first - so a hung
+        // lookup cannot leave the old wallet's name attached indefinitely.
+        var staleTimer = setTimeout(function () {
+            if (!settled &&
+                walletConnectPeerLatest.get(connector) === connection) {
+                walletConnectPeerNames.delete(connector);
+            }
+        }, 3000);
+        (_b = (_a = staleTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        connector
+            .getProvider()
+            .then(function (provider) {
+            settled = true;
+            clearTimeout(staleTimer);
+            // Only the NEWEST session's lookup may write. A previous session's
+            // slow resolution landing late would otherwise overwrite the
+            // current wallet's name with the old one.
+            if (walletConnectPeerLatest.get(connector) !== connection) {
+                return;
+            }
+            var peer = (0, provider_1.readWalletConnectPeer)(provider);
+            if (peer === null || peer === void 0 ? void 0 : peer.name) {
+                walletConnectPeerNames.set(connector, peer.name);
+                logger_1.logger.debug("WagmiEventHandler: WalletConnect peer resolved", {
+                    peer: peer.name,
+                });
+            }
+            else {
+                // Resolved WITHOUT peer metadata: the previous wallet's name is
+                // disproven for this session, not merely unproven. Drop it, and
+                // let a later event retry the lookup - the session may simply
+                // not have populated its peer yet.
+                walletConnectPeerNames.delete(connector);
+                walletConnectPeerLookups.delete(connection);
+            }
+        })
+            .catch(function () {
+            settled = true;
+            clearTimeout(staleTimer);
+            // The new session could not be inspected, so the PREVIOUS wallet's
+            // name must not keep serving: drop it and fall back to the
+            // connector's own name until a later session resolves. Guarded so
+            // an old session's late failure cannot clear a newer resolution.
+            if (walletConnectPeerLatest.get(connector) === connection) {
+                walletConnectPeerNames.delete(connector);
+            }
+            // A failed lookup must not permanently disqualify the connection:
+            // the connector may just have been initialising. A later event
+            // retries.
+            walletConnectPeerLookups.delete(connection);
+        });
     };
     /**
      * Clean up all subscriptions
      */
     WagmiEventHandler.prototype.cleanup = function () {
+        this.wrapRetryTimers.forEach(function (t) { return clearTimeout(t); });
+        this.wrapRetryTimers.clear();
         logger_1.logger.debug("WagmiEventHandler: Cleaning up subscriptions");
         if (!this.disposed) {
             this.disposed = true;