@formo/analytics 1.37.0 → 1.38.0

package/dist/cjs/src/provider/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Provider-related exports
  */
-export { detectInjectedProviderInfo, isValidProvider, DEFAULT_PROVIDER_ICON, } from './detection';
+export { detectInjectedProviderInfo, isValidProvider, readWalletConnectPeer, isUserRejectionError, DEFAULT_PROVIDER_ICON, } from './detection';
 export type { WalletProviderFlags, ProviderInfo, } from './detection';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/src/provider/index.js

@@ -3,9 +3,11 @@
  * Provider-related exports
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_PROVIDER_ICON = exports.isValidProvider = exports.detectInjectedProviderInfo = void 0;
+exports.DEFAULT_PROVIDER_ICON = exports.isUserRejectionError = exports.readWalletConnectPeer = exports.isValidProvider = exports.detectInjectedProviderInfo = void 0;
 var detection_1 = require("./detection");
 Object.defineProperty(exports, "detectInjectedProviderInfo", { enumerable: true, get: function () { return detection_1.detectInjectedProviderInfo; } });
 Object.defineProperty(exports, "isValidProvider", { enumerable: true, get: function () { return detection_1.isValidProvider; } });
+Object.defineProperty(exports, "readWalletConnectPeer", { enumerable: true, get: function () { return detection_1.readWalletConnectPeer; } });
+Object.defineProperty(exports, "isUserRejectionError", { enumerable: true, get: function () { return detection_1.isUserRejectionError; } });
 Object.defineProperty(exports, "DEFAULT_PROVIDER_ICON", { enumerable: true, get: function () { return detection_1.DEFAULT_PROVIDER_ICON; } });
 //# sourceMappingURL=index.js.map

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

@@ -19,6 +19,17 @@ export interface IFormoAnalytics {
     page(category?: string, name?: string, properties?: IFormoEventProperties, context?: IFormoEventContext, callback?: (...args: unknown[]) => void): Promise<void>;
     reset(): void;
     cleanup(): void;
+    /**
+     * Track a constructed (non-injected) EIP-1193 provider, such as a
+     * WalletConnect or Ledger provider the app built itself. Returns true when
+     * the provider is tracked, false when refused (wagmi mode, EVM disabled,
+     * or not a valid provider).
+     */
+    registerProvider(provider: EIP1193Provider, info?: {
+        name?: string;
+        rdns?: string;
+        icon?: `data:image/${string}`;
+    }): boolean;
     detect(params: {
         rdns: string;
         providerName: string;
@@ -171,6 +182,18 @@ export interface ReferralOptions {
  * Allows the SDK to hook into Wagmi v2 wallet events instead of wrapping EIP-1193 providers
  */
 export interface WagmiOptions {
+    /**
+     * OPT-IN: fall back to the EIP-1193 request wrapper for wallet calls the
+     * wagmi caches cannot see - imperative viem calls
+     * (walletClient.sendTransaction, .signMessage, .writeContract, raw
+     * request) that create no mutation. The active connector's provider gets
+     * the same wrapper the SDK's default mode uses. Off by default: wagmi
+     * mode's baseline contract is observing wagmi state and caches without
+     * touching the signing transport, and enabling this is an explicit,
+     * auditable decision. Hook-driven calls are never double-counted (a
+     * pending wagmi mutation stands the wrapper down).
+     */
+    eip1193Fallback?: boolean;
     /**
      * Wagmi config instance from createConfig()
      * The SDK will subscribe to this config's state changes to track wallet events

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

@@ -20,6 +20,22 @@ export type WrappedRequestFunction = (<T>(args: RequestArguments) => Promise<T |
     [WRAPPED_REQUEST_SYMBOL]?: boolean;
 };
 export declare const WRAPPED_REQUEST_REF_SYMBOL: unique symbol;
+/**
+ * The SDK instance a provider's installed wrapper currently reports to.
+ *
+ * The wrapper survives an SDK rebuild (nothing restores `provider.request`),
+ * and its closure holds the instance that installed it - whose event queue
+ * is CLOSED after cleanup. Without this slot, a rebuilt instance saw
+ * "already wrapped", reported success, and every request-derived event
+ * silently died in the old instance's queue. The slot holds the LIST of
+ * instances that registered this provider, in registration order; the
+ * wrapper routes each call to the newest one still live. A list rather
+ * than a single ref for two reasons: with several live instances (multi
+ * write-key pages) a cleanup degrades to newest-live-wins instead of
+ * dead-instance-wins, and the list is attached at install time, so
+ * rebinding mutates it and works even on a provider frozen AFTER wrapping.
+ */
+export declare const WRAPPED_REQUEST_OWNER_SYMBOL: unique symbol;
 export interface WrappedEIP1193Provider extends EIP1193Provider {
     [WRAPPED_REQUEST_REF_SYMBOL]?: WrappedRequestFunction;
 }

package/dist/cjs/src/types/provider.js

@@ -1,6 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WRAPPED_REQUEST_REF_SYMBOL = exports.WRAPPED_REQUEST_SYMBOL = void 0;
+exports.WRAPPED_REQUEST_OWNER_SYMBOL = exports.WRAPPED_REQUEST_REF_SYMBOL = exports.WRAPPED_REQUEST_SYMBOL = void 0;
 exports.WRAPPED_REQUEST_SYMBOL = Symbol("formoWrappedRequest");
 exports.WRAPPED_REQUEST_REF_SYMBOL = Symbol("formoWrappedRequestRef");
+/**
+ * The SDK instance a provider's installed wrapper currently reports to.
+ *
+ * The wrapper survives an SDK rebuild (nothing restores `provider.request`),
+ * and its closure holds the instance that installed it - whose event queue
+ * is CLOSED after cleanup. Without this slot, a rebuilt instance saw
+ * "already wrapped", reported success, and every request-derived event
+ * silently died in the old instance's queue. The slot holds the LIST of
+ * instances that registered this provider, in registration order; the
+ * wrapper routes each call to the newest one still live. A list rather
+ * than a single ref for two reasons: with several live instances (multi
+ * write-key pages) a cleanup degrades to newest-live-wins instead of
+ * dead-instance-wins, and the list is attached at install time, so
+ * rebinding mutates it and works even on a provider frozen AFTER wrapping.
+ */
+exports.WRAPPED_REQUEST_OWNER_SYMBOL = Symbol("formoWrappedRequestOwner");
 //# sourceMappingURL=provider.js.map

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

@@ -1,2 +1,2 @@
-export declare const version = "1.37.0";
+export declare const version = "1.38.0";
 //# 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.37.0';
+exports.version = '1.38.0';
 //# sourceMappingURL=version.js.map

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

@@ -204,6 +204,7 @@ export declare class WagmiEventHandler {
      * already recorded the new address synchronously by the time this runs. The
      * `lastAddress` check below is what makes the two paths mutually exclusive.
      */
+    private handleActiveAddressChangeEntryKick;
     private handleActiveAddressChange;
     /**
      * Record and emit a chain move for the wallet already being tracked.
@@ -266,6 +267,26 @@ export declare class WagmiEventHandler {
     /**
      * 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.
+     */
+    hasMatchingPendingMutation(method: string, params: unknown[]): boolean;
+    /**
+     * 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.
+     */
+    private mutationAttribution;
     private handleSignatureMutation;
     /**
      * Handle transaction mutations (sendTransaction, writeContract)
@@ -320,6 +341,29 @@ export declare class WagmiEventHandler {
      * Get the connector name from Wagmi state
      */
     private getConnectorName;
+    /**
+     * 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.
+     */
+    private wrapActiveConnectorProvider;
+    private kickWalletConnectPeerLookup;
     /**
      * Clean up all subscriptions
      */

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,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 = 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();
+/** Connections whose provider already has the hybrid-capture wrapper. */
+var wagmiWrappedConnections = new WeakSet();
 /**
  * Pending transactions, shared per destination rather than per handler.
  *
@@ -615,6 +639,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,7 +902,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) {
@@ -888,6 +923,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 +1202,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 +1219,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*/];
@@ -1632,11 +1690,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 +1775,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 +1843,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 +1973,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 +1983,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 +2074,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 +2088,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 +2137,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 +2154,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,7 +2258,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 = (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