@formo/analytics 1.38.0 → 1.38.2

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

@@ -71,6 +71,16 @@ var RESERVED_FIELDS = new Set([
     "transactionHash",
     "function_name",
     "function_args",
+    // Wallet attribution. Function args are spread AFTER the attribution
+    // properties, so an ABI input named `providerName` would silently
+    // relabel the wallet on every broadcast and receipt event. `rdns` is
+    // reserved with it even though THIS path (wagmi mutation attribution)
+    // emits only the name: elsewhere in the SDK - the EIP-1193 request path
+    // and connect events - `rdns` is the wallet-identity key, so an ABI
+    // input by that name would land in the same warehouse column as real
+    // wallet identities.
+    "providerName",
+    "rdns",
 ]);
 /**
  * Connections already announced to a destination during this page load.
@@ -238,8 +248,6 @@ var walletConnectPeerLookups = new WeakSet();
  * 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.
  *
@@ -424,6 +432,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;
@@ -598,6 +657,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);
@@ -903,6 +966,19 @@ var WagmiEventHandler = /** @class */ (function () {
             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.
@@ -1439,10 +1515,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*/];
                         }
@@ -1488,7 +1585,7 @@ var WagmiEventHandler = /** @class */ (function () {
                         });
                         return [4 /*yield*/, this.applyChainForTrackedWallet(address, chainId)];
                     case 1:
-                        _a.sent();
+                        _d.sent();
                         return [2 /*return*/];
                 }
             });
@@ -2246,6 +2343,75 @@ var WagmiEventHandler = /** @class */ (function () {
         });
         return found;
     };
+    /**
+     * A specific connector's name and rdns, for the fallback-wrapped
+     * provider's request-derived events.
+     *
+     * The NAME is exactly what the hook path emits for that connector
+     * (`getConnectorName`: the live WalletConnect peer for a WalletConnect
+     * connector, the connector's own name otherwise), so a branded connector
+     * keeps its name on both paths and a session that changes wallets
+     * renames on both. The rdns is the connector's when wagmi knows it as
+     * ONE value (EIP-6963 discovered connectors carry theirs, some as a
+     * one-element list); a connector that matches several rdns values does
+     * not say which one this provider is, so nothing is passed and the
+     * registry keeps the sniffed one.
+     */
+    WagmiEventHandler.prototype.attributionForConnector = function (connector, state) {
+        var name = this.nameForConnector(connector, state);
+        if (!name) {
+            return undefined;
+        }
+        var raw = connector.rdns;
+        var rdns = typeof raw === "string" && raw.length > 0
+            ? raw
+            : Array.isArray(raw) && raw.length === 1 && typeof raw[0] === "string" && raw[0].length > 0
+                ? raw[0]
+                : undefined;
+        return __assign({ name: name }, (rdns && { rdns: rdns }));
+    };
+    /**
+     * Resolver handed to the registry at wrap time, read at each request
+     * start. BOUND to the connector whose `getProvider` resolved to the
+     * wrapped provider, not to whichever connector is current: an app can
+     * keep a wallet client over a previous connector's provider and issue a
+     * request through it after switching, and that request belongs to the
+     * wallet that handles it. The peer name is still read live. A provider
+     * SHARED by two connectors is re-bound when the new connector's
+     * resolution lands (one microtask for an injected connector); a request
+     * issued inside that gap keeps the previous label.
+     */
+    WagmiEventHandler.prototype.boundConnectorAttribution = function (connector) {
+        var _this = this;
+        return function () {
+            if (_this.disposed)
+                return undefined;
+            try {
+                return _this.attributionForConnector(connector, _this.getState());
+            }
+            catch (_a) {
+                return undefined;
+            }
+        };
+    };
+    /** `getConnectorName` for a SPECIFIC connector, current or not. */
+    WagmiEventHandler.prototype.nameForConnector = function (connector, state) {
+        var _a;
+        var cached = walletConnectPeerNames.get(connector);
+        if (cached) {
+            return cached;
+        }
+        var current = state.current
+            ? (_a = state.connections.get(state.current)) === null || _a === void 0 ? void 0 : _a.connector
+            : undefined;
+        if (current === connector) {
+            // Backstop kick, as in getConnectorName; only the current connection
+            // has a session to look up.
+            this.kickWalletConnectPeerLookup(state);
+        }
+        var name = connector.name;
+        return typeof name === "string" && name.length > 0 ? name : undefined;
+    };
     /**
      * Get the connector name from Wagmi state
      */
@@ -2267,30 +2433,10 @@ var WagmiEventHandler = /** @class */ (function () {
         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) {
+    WagmiEventHandler.prototype.wrapActiveConnectorProvider = function (state, isRetry) {
         var _this = this;
-        var _a, _b;
+        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
@@ -2299,25 +2445,124 @@ var WagmiEventHandler = /** @class */ (function () {
         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" ||
-            wagmiWrappedConnections.has(connection)) {
+        if (!connection || typeof (connector === null || connector === void 0 ? void 0 : connector.getProvider) !== "function") {
             return;
         }
-        wagmiWrappedConnections.add(connection);
-        connector
-            .getProvider()
+        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;
-            (_b = (_a = _this.formo)._wrapWagmiProvider) === null || _b === void 0 ? void 0 : _b.call(_a, 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, _this.boundConnectorAttribution(connector));
+            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; retry on the next connection.
-            wagmiWrappedConnections.delete(connection);
+            // Mutation-only capture remains.
+            retryAfterFailure();
         });
     };
     WagmiEventHandler.prototype.kickWalletConnectPeerLookup = function (state) {
@@ -2407,6 +2652,8 @@ var WagmiEventHandler = /** @class */ (function () {
      * Clean up all subscriptions
      */
     WagmiEventHandler.prototype.cleanup = function () {
+        this.wrapRetryTimers.forEach(function (t) { return clearTimeout(t); });
+        this.wrapRetryTimers.clear();
         logger.debug("WagmiEventHandler: Cleaning up subscriptions");
         if (!this.disposed) {
             this.disposed = true;

package/dist/esm/src/wagmi/types.d.ts

@@ -31,6 +31,12 @@ export interface WagmiConnector {
     name: string;
     type: string;
     uid: string;
+    /**
+     * Any connector implementation may expose an rdns; EIP-6963 discovered
+     * connectors are one source. A connector matching several rdns values
+     * lists them all.
+     */
+    rdns?: string | readonly string[];
 }
 /**
  * Wagmi config interface

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

@@ -185,7 +185,15 @@ export function buildSafeFunctionArgs(functionArgs, reservedFields) {
     var result = {};
     for (var _i = 0, _a = Object.entries(functionArgs); _i < _a.length; _i++) {
         var _b = _a[_i], key = _b[0], val = _b[1];
-        var safeKey = reservedFields.has(key) ? "arg_".concat(key) : key;
+        // A prefixed key must not land on another argument's own name: an ABI
+        // with both `to` and `arg_to` would otherwise keep only one of them,
+        // whichever came later. Keep prefixing until the name is free.
+        var safeKey = key;
+        if (reservedFields.has(key)) {
+            do {
+                safeKey = "arg_".concat(safeKey);
+            } while (safeKey in functionArgs);
+        }
         result[safeKey] = val;
         // If the value is a nested object (struct), flatten it
         // Skip flattened keys that would overwrite existing top-level args