@formo/analytics 1.36.0 → 1.38.0

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

@@ -54,6 +54,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import { SignatureStatus, TransactionStatus } from "../types/events";
 import { logger } from "../logger";
+import { readWalletConnectPeer, isUserRejectionError } from "../provider";
+import { readBatchId, readBatchStatusCode, readBatchChainId, batchCallOutcome, batchReceiptForCall, } from "../evm/batch";
 import { encodeWriteContractData, concatCalldataWithSuffix, extractFunctionArgs, buildSafeFunctionArgs, } from "./utils";
 /**
  * Built-in transaction fields that could collide with function args.
@@ -196,6 +198,48 @@ 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 = isUserRejectionError;
+/**
+ * Real wallet names behind WalletConnect connectors, resolved lazily.
+ *
+ * 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.
+ */
+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();
+/** Connections whose provider already has the hybrid-capture wrapper. */
+var wagmiWrappedConnections = new WeakSet();
 /**
  * Pending transactions, shared per destination rather than per handler.
  *
@@ -205,6 +249,7 @@ var ownerKey = function (writeKey, config) {
  * broadcast to match the receipt against.
  */
 var pendingTransactionsByDestination = new Map();
+var pendingBatchesByDestination = 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
@@ -219,6 +264,7 @@ function schedulePendingTransactionExpiry(key) {
     var timer = setTimeout(function () {
         pendingTransactionExpiry.delete(key);
         pendingTransactionsByDestination.delete(key);
+        pendingBatchesByDestination.delete(key);
     }, MARKER_GRACE_MS);
     (_b = (_a = timer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
     pendingTransactionExpiry.set(key, timer);
@@ -285,6 +331,7 @@ export function __resetSeededWallet() {
     pendingTransactionExpiry.forEach(function (t) { return clearTimeout(t); });
     pendingTransactionExpiry.clear();
     pendingTransactionsByDestination.clear();
+    pendingBatchesByDestination.clear();
     announcedConnections.clear();
     liveHandlers.clear();
     markerExpiry.forEach(function (timer) { return clearTimeout(timer); });
@@ -497,6 +544,21 @@ var WagmiEventHandler = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(WagmiEventHandler.prototype, "pendingBatches", {
+        /** Broadcast batches awaiting `callsStatus`, shared like the map above. */
+        get: function () {
+            var _a;
+            var key = (_a = this.ownerKey) !== null && _a !== void 0 ? _a : "";
+            var map = pendingBatchesByDestination.get(key);
+            if (!map) {
+                map = new Map();
+                pendingBatchesByDestination.set(key, map);
+            }
+            return map;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Set up listeners for wallet connection, disconnection, and chain changes
      */
@@ -573,6 +635,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") {
@@ -825,7 +898,7 @@ 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) {
@@ -846,6 +919,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
@@ -1113,6 +1198,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;
@@ -1120,6 +1215,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*/];
@@ -1449,8 +1545,23 @@ var WagmiEventHandler = /** @class */ (function () {
             return;
         }
         var queryType = queryKey[0];
-        // Only handle waitForTransactionReceipt queries
-        if (queryType !== "waitForTransactionReceipt") {
+        // Only the two query families that settle something we broadcast:
+        // waitForTransactionReceipt for single transactions, callsStatus for
+        // EIP-5792 batches (both useCallsStatus and useWaitForCallsStatus share
+        // the 'callsStatus' key, in wagmi 2 and 3 alike).
+        if (queryType !== "waitForTransactionReceipt" && queryType !== "callsStatus") {
+            return;
+        }
+        // Batch settlement dedupes on the pending-batch registry, NOT on
+        // processedQueries: settling deletes the registration, so a duplicate
+        // delivery finds nothing to do. A processed-key here would be worse
+        // than redundant - the status query can complete BEFORE the sendCalls
+        // mutation registers the batch (TanStack dispatches a mutation's
+        // success state after its onSuccess callbacks, and apps await the
+        // status inside onSuccess), and a key recorded on that early skip
+        // would block every refetch from ever settling the batch.
+        if (queryType === "callsStatus") {
+            this.handleCallsStatusQuery(query);
             return;
         }
         var state = query.state;
@@ -1483,6 +1594,109 @@ var WagmiEventHandler = /** @class */ (function () {
         // Clean up old processed queries to prevent memory leaks
         cleanupOldEntries(this.processedQueries);
     };
+    /**
+     * Settle a just-registered batch from a status query that already ran.
+     *
+     * Best-effort by design: the minimal QueryClient interface the SDK
+     * accepts is not guaranteed to expose cache lookup, and a missing
+     * `getAll` just means settlement waits for the next query event, which
+     * is where it normally comes from anyway.
+     */
+    WagmiEventHandler.prototype.settleFromCachedCallsStatus = function (batchId) {
+        var _a, _b, _c;
+        try {
+            var cache = (_a = this.queryClient) === null || _a === void 0 ? void 0 : _a.getQueryCache();
+            var queries = (_b = cache === null || cache === void 0 ? void 0 : cache.getAll) === null || _b === void 0 ? void 0 : _b.call(cache);
+            if (!Array.isArray(queries))
+                return;
+            for (var _i = 0, queries_1 = queries; _i < queries_1.length; _i++) {
+                var query = queries_1[_i];
+                var key = query === null || query === void 0 ? void 0 : query.queryKey;
+                if (Array.isArray(key) &&
+                    key[0] === "callsStatus" &&
+                    ((_c = key[1]) === null || _c === void 0 ? void 0 : _c.id) === batchId) {
+                    this.handleCallsStatusQuery(query);
+                }
+            }
+        }
+        catch (error) {
+            logger.debug("WagmiEventHandler: cached callsStatus scan failed", error);
+        }
+    };
+    /**
+     * Settle an EIP-5792 batch from a `callsStatus` query.
+     *
+     * Only batches whose broadcast this SDK observed are settled: the batch id
+     * must be in `pendingBatches`, for the same reason receipt queries are
+     * gated on an observed hash - queries are visible to any code sharing the
+     * QueryClient, and emitting for an id we never saw broadcast would let a
+     * forged query invent transactions.
+     *
+     * Outcome semantics are shared with the EIP-1193 path (`src/evm/batch.ts`):
+     * per-call receipts outrank the batch verdict, an atomic batch's single
+     * receipt reaches every call, and a 600 leaves receipt-less calls
+     * unsettled rather than guessed.
+     */
+    WagmiEventHandler.prototype.handleCallsStatusQuery = function (query) {
+        var _this = this;
+        var _a;
+        if (!this.formo.isAutocaptureEnabled("transaction")) {
+            return;
+        }
+        var queryKey = query.queryKey;
+        // Query key format: ['callsStatus', { id, ... }]
+        var params = queryKey[1];
+        var batchId = params === null || params === void 0 ? void 0 : params.id;
+        if (!batchId) {
+            return;
+        }
+        var pending = this.pendingBatches.get(batchId);
+        if (!pending) {
+            logger.debug("WagmiEventHandler: unobserved batch", { batchId: batchId });
+            return;
+        }
+        var state = query.state;
+        if (state.status !== "success" || !state.data) {
+            return;
+        }
+        try {
+            var res_1 = state.data;
+            var code_1 = readBatchStatusCode(res_1);
+            // Below 200 the batch is still pending; the query will update again.
+            if (code_1 === undefined || code_1 < 200) {
+                return;
+            }
+            logger.debug("WagmiEventHandler: batch settled", { batchId: batchId, code: code_1 });
+            // An explicit mutation chain is authoritative. Otherwise prefer the
+            // chain the settlement result names - EIP-5792 v2 reports where the
+            // batch actually landed - over one inferred from the connection at
+            // broadcast, which goes stale if the wallet moves chains while the
+            // prompt is up. Same precedence as the single-transaction receipt
+            // path.
+            var settledChainId_1 = pending.chainIdWasExplicit
+                ? pending.chainId
+                : (_a = readBatchChainId(res_1)) !== null && _a !== void 0 ? _a : pending.chainId;
+            pending.calls.forEach(function (call, index) {
+                var receipt = batchReceiptForCall(res_1, index, pending.calls.length);
+                var outcome = batchCallOutcome(code_1, receipt);
+                // 600 means SOME calls reverted, so a call with no receipt of its
+                // own has not been decided. Reporting it either way would invent a
+                // result; leaving it unsettled is the honest answer.
+                if (outcome === undefined)
+                    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 }
+                    : {})), __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);
+        }
+        catch (error) {
+            logger.error("WagmiEventHandler: callsStatus error:", error);
+        }
+    };
     /**
      * Handle waitForTransactionReceipt query completion
      * Emits CONFIRMED or REVERTED transaction status
@@ -1557,9 +1771,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);
         }
@@ -1612,12 +1826,89 @@ var WagmiEventHandler = /** @class */ (function () {
         if (mutationType === "sendTransaction" || mutationType === "writeContract") {
             this.handleTransactionMutation(mutationType, mutation);
         }
+        // Handle EIP-5792 batch mutations (useSendCalls). Absent this branch,
+        // wagmi-mode apps captured nothing for a batch: the EIP-1193 request
+        // wrapper that handles `wallet_sendCalls` is never installed in wagmi
+        // mode, so the mutation was the only place the batch was visible at all.
+        if (mutationType === "sendCalls") {
+            this.handleSendCallsMutation(mutation);
+        }
         // Clean up old processed mutations to prevent memory leaks
         cleanupOldEntries(this.processedMutations);
     };
     /**
      * 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")) {
@@ -1678,7 +1969,7 @@ var WagmiEventHandler = /** @class */ (function () {
                 chainId: chainId,
                 address: address,
                 message: message,
-            });
+            }, this.mutationAttribution());
         }
         catch (error) {
             logger.error("WagmiEventHandler: Error handling signature mutation:", error);
@@ -1688,7 +1979,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;
         }
@@ -1779,7 +2070,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(__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.debug("WagmiEventHandler: Stored pending transaction for confirmation", {
                     transactionHash: normalizedHash,
@@ -1793,14 +2084,99 @@ 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.error("WagmiEventHandler: Error handling transaction mutation:", error);
         }
     };
+    /**
+     * One `transaction` event per call in an EIP-5792 batch, wagmi path.
+     *
+     * Mirrors `EvmRequestTracker.trackBatchedCalls` exactly: the CALL is the
+     * unit of attribution, so each call gets its own STARTED at pending and
+     * BROADCASTED (with `batch_id`) when the wallet returns an id. The batch's
+     * on-chain outcome arrives through the `callsStatus` query, handled in
+     * `handleCallsStatusQuery`.
+     *
+     * Rejection matches the 1193 path's rule: only a user rejection (4001
+     * anywhere in the error chain) marks the calls rejected - one dismissal
+     * dismisses the whole prompt, so every call in it is rejected, and
+     * reporting only the first would undercount. Any other error (a wallet
+     * without EIP-5792 support, a transport failure) emits nothing further:
+     * inventing a rejection the user never made would be worse.
+     */
+    WagmiEventHandler.prototype.handleSendCallsMutation = function (mutation) {
+        var _this = this;
+        if (!this.formo.isAutocaptureEnabled("transaction")) {
+            return;
+        }
+        var state = mutation.state;
+        var variables = state.variables || {};
+        var rawCalls = Array.isArray(variables.calls) ? variables.calls : [];
+        if (rawCalls.length === 0) {
+            return;
+        }
+        // Same resolution order as single transactions: an explicit per-call
+        // value beats the tracked connection.
+        var explicitChainId = normalizeChainId(variables.chainId);
+        var chainId = explicitChainId !== null && explicitChainId !== void 0 ? explicitChainId : this.trackingState.lastChainId;
+        var accountAddress = resolveAccountAddress(variables.account);
+        var userAddress = accountAddress || this.trackingState.lastAddress;
+        if (!userAddress) {
+            logger.warn("WagmiEventHandler: sendCalls without address");
+            return;
+        }
+        try {
+            var calls_1 = rawCalls.map(function (call) { return ({
+                to: call === null || call === void 0 ? void 0 : call.to,
+                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(__assign({ batch_size: calls_1.length, batch_index: index }, attribution_1), extra));
+                });
+            };
+            if (state.status === "pending") {
+                // STARTED carries no batch id, exactly as a single transaction has
+                // no hash yet: the wallet has not issued one.
+                logger.debug("WagmiEventHandler: sendCalls start", { calls: calls_1.length });
+                emitAll(TransactionStatus.STARTED);
+            }
+            else if (state.status === "success") {
+                var batchId = readBatchId(state.data);
+                logger.debug("WagmiEventHandler: sendCalls broadcast", { batchId: batchId });
+                emitAll(TransactionStatus.BROADCASTED, batchId ? { batch_id: batchId } : undefined);
+                if (batchId) {
+                    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());
+                        for (var i = 0; i < 50 && i < keys.length; i++) {
+                            this.pendingBatches.delete(keys[i]);
+                        }
+                    }
+                    // The status query can have completed BEFORE this registration:
+                    // TanStack dispatches a mutation's success state after its
+                    // onSuccess callbacks, and apps await waitForCallsStatus inside
+                    // onSuccess. That early query event found no registration and did
+                    // nothing, so look for its settled result in the cache now.
+                    this.settleFromCachedCallsStatus(batchId);
+                }
+            }
+            else if (state.status === "error") {
+                if (isUserRejection(state.error)) {
+                    logger.debug("WagmiEventHandler: sendCalls rejected");
+                    emitAll(TransactionStatus.REJECTED);
+                }
+            }
+        }
+        catch (error) {
+            logger.error("WagmiEventHandler: sendCalls error:", error);
+        }
+    };
     /**
      * Get the current Wagmi state
      * Supports both getState() method and direct state property access
@@ -1878,7 +2254,154 @@ 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;
+    };
+    /**
+     * Start resolving the wallet behind a WalletConnect connection.
+     *
+     * Fire-and-forget on purpose: emission paths are synchronous by design
+     * and must never wait (see the connect marker comment). Called at the
+     * START of the status/address flows rather than only at read time - the
+     * lookup is one microtask for an initialised connector, and the emission
+     * sits behind several awaits, so kicking early usually means even the
+     * FIRST connect names the real wallet. When the race is lost the event
+     * honestly says "WalletConnect" and every later event names the peer.
+     */
+    /**
+     * Install the request wrapper on the active connector's provider.
+     *
+     * This is what lets wagmi mode capture IMPERATIVE viem calls
+     * (walletClient.sendTransaction / .signMessage / .writeContract / raw
+     * request), which create no mutation and were silently lost. Hook-driven
+     * calls stay owned by the mutation handlers via the pending-mutation
+     * dedup. Fire-and-forget per connection; a provider that cannot be
+     * produced simply keeps mutation-only capture.
+     */
+    WagmiEventHandler.prototype.wrapActiveConnectorProvider = function (state) {
+        var _this = this;
+        var _a, _b;
+        // 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;
+        }
+        var connection = state.current
+            ? state.connections.get(state.current)
+            : undefined;
+        var connector = connection === null || connection === void 0 ? void 0 : connection.connector;
+        if (!connection ||
+            typeof (connector === null || connector === void 0 ? void 0 : connector.getProvider) !== "function" ||
+            wagmiWrappedConnections.has(connection)) {
+            return;
+        }
+        wagmiWrappedConnections.add(connection);
+        connector
+            .getProvider()
+            .then(function (provider) {
+            var _a, _b;
+            (_b = (_a = _this.formo)._wrapWagmiProvider) === null || _b === void 0 ? void 0 : _b.call(_a, provider);
+        })
+            .catch(function () {
+            // Mutation-only capture remains; retry on the next connection.
+            wagmiWrappedConnections.delete(connection);
+        });
+    };
+    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 = readWalletConnectPeer(provider);
+            if (peer === null || peer === void 0 ? void 0 : peer.name) {
+                walletConnectPeerNames.set(connector, peer.name);
+                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