@formo/analytics 1.37.0 → 1.38.0

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

@@ -5,6 +5,13 @@ import { AutocaptureEventType } from "../tracking/TrackingPolicy";
 /** What the request tracker needs from the SDK that owns it. */
 export interface EvmRequestTrackerDeps {
     isAutocaptureEnabled(eventType: AutocaptureEventType): boolean;
+    /**
+     * Hybrid-capture dedup: true when a PENDING wagmi mutation already covers
+     * this request, so the mutation handler owns the capture. TanStack sets a
+     * mutation pending BEFORE its mutationFn issues the wallet call, so a
+     * hook-driven request always matches; an imperative one never does.
+     */
+    shouldSkipRequestCapture?(method: string, params: unknown[]): boolean;
     signature(params: {
         status: SignatureStatus;
         chainId?: ChainID;
@@ -23,16 +30,6 @@ export interface EvmRequestTrackerDeps {
         function_args?: Record<string, unknown>;
     }, properties?: IFormoEventProperties): Promise<void>;
 }
-/**
- * Autocapture for signatures and transactions, by wrapping a provider's
- * `request`.
- *
- * The wrapper is deliberately thin: it observes the call the dapp was already
- * making and never issues one of its own. That rule is why the chain a
- * request ran on is read from `eth_chainId` calls the app makes, rather than
- * probed - an SDK-issued lookup on a serialising transport can wedge the
- * user's wallet, which is never an acceptable price for a label.
- */
 export declare class EvmRequestTracker {
     private readonly wallet;
     private readonly registry;
@@ -50,6 +47,8 @@ export declare class EvmRequestTracker {
     constructor(wallet: WalletStateStore, registry: EvmProviderRegistry, deps: EvmRequestTrackerDeps);
     /** Stop every poll in flight. Terminal, like the event queue's close(). */
     cleanup(): void;
+    /** Providers whose owner list includes this instance; pruned on cleanup. */
+    private wrappedProviders;
     /** Re-arm a poll, unless this tracker has been torn down. */
     private schedulePoll;
     /**
@@ -59,6 +58,25 @@ export declare class EvmRequestTracker {
      * would be missed for the rest of the session.
      */
     registerRequestListeners(provider: EIP1193Provider): boolean;
+    /** Install the wrapper function onto the provider; separated so the
+     * routing shim above stays small. */
+    private installWrappedRequest;
+    /**
+     * The wrapper body proper: everything a request observation does, run
+     * against THIS instance's registry, wallet state, and event queue. Kept
+     * as a method so a surviving wrapper installed by a previous SDK
+     * instance can hand calls to the current one.
+     */
+    private dispatchWrappedRequest;
+    /**
+     * Wallet attribution for request-derived events.
+     *
+     * Live per read through the registry, so a WalletConnect session names
+     * its actual signer ("MetaMask Wallet", "Ledger Live") - the live-test
+     * rows had provider_name EMPTY on every signature and transaction, which
+     * made per-wallet activity unanswerable in the warehouse.
+     */
+    private attributionFor;
     private buildSignatureEventPayload;
     private buildTransactionEventPayload;
     /**

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

@@ -56,10 +56,20 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { logger } from "../logger";
+import { isUserRejectionError } from "../provider";
 import { parseChainId } from "../utils/chain";
 import { validateAndChecksumAddress } from "../utils/address";
-import { SignatureStatus, TransactionStatus, WRAPPED_REQUEST_SYMBOL, WRAPPED_REQUEST_REF_SYMBOL, } from "../types";
+import { SignatureStatus, TransactionStatus, WRAPPED_REQUEST_SYMBOL, WRAPPED_REQUEST_REF_SYMBOL, WRAPPED_REQUEST_OWNER_SYMBOL, } from "../types";
 import { readBatchId, readBatchStatusCode, batchCallOutcome, batchReceiptForCall, } from "./batch";
 /**
  * Decode a hex-encoded `personal_sign` message.
@@ -97,6 +107,19 @@ function hexToUtf8(hex) {
  * probed - an SDK-issued lookup on a serialising transport can wedge the
  * user's wallet, which is never an acceptable price for a label.
  */
+/**
+ * Providers with a dispatch already on the synchronous call stack.
+ *
+ * A page can end up with LAYERED Formo wrappers: another library wraps our
+ * wrapper, the SDK rebuilds, and the new instance wraps the outer function
+ * because the marker is not on it. Both layers route to the same newest
+ * live tracker, which would instrument one user request twice. Every
+ * dispatch issues its underlying request synchronously (deliberately -
+ * the wallet call always goes out first), so an inner shim reached during
+ * that window belongs to the SAME user request and passes straight
+ * through.
+ */
+var dispatchInFlight = new WeakSet();
 var EvmRequestTracker = /** @class */ (function () {
     function EvmRequestTracker(wallet, registry, deps) {
         this.wallet = wallet;
@@ -112,12 +135,28 @@ var EvmRequestTracker = /** @class */ (function () {
          */
         this.polls = new Set();
         this.disposed = false;
+        /** Providers whose owner list includes this instance; pruned on cleanup. */
+        this.wrappedProviders = new Set();
     }
     /** Stop every poll in flight. Terminal, like the event queue's close(). */
     EvmRequestTracker.prototype.cleanup = function () {
+        var _this = this;
         this.disposed = true;
         this.polls.forEach(function (timer) { return clearTimeout(timer); });
         this.polls.clear();
+        // Remove this instance from every provider's owner list. The lists
+        // live on LONG-LIVED provider objects; leaving disposed trackers in
+        // them retains each old instance's whole object graph across rebuilds,
+        // growing without bound under HMR.
+        this.wrappedProviders.forEach(function (provider) {
+            var owners = provider[WRAPPED_REQUEST_OWNER_SYMBOL];
+            if (Array.isArray(owners)) {
+                var idx = owners.indexOf(_this);
+                if (idx !== -1)
+                    owners.splice(idx, 1);
+            }
+        });
+        this.wrappedProviders.clear();
     };
     /** Re-arm a poll, unless this tracker has been torn down. */
     EvmRequestTracker.prototype.schedulePoll = function (fn, delayMs) {
@@ -143,19 +182,118 @@ var EvmRequestTracker = /** @class */ (function () {
             logger.error("Provider not found for request (signature, transaction) tracking");
             return false;
         }
-        // Check if the provider is already wrapped with our SDK's wrapper
+        // Already wrapped: take OWNERSHIP rather than skipping. The wrapper
+        // survives an SDK rebuild and closes over the instance that installed
+        // it, whose queue is closed after cleanup - "skip" made the rebuilt
+        // instance report success while every request-derived event died in
+        // the dead instance's queue. The wrapper reads the owner slot per call.
         var currentRequest = provider.request;
         if (this.registry.isWrapped(provider, currentRequest)) {
-            logger.info("Provider already wrapped with our SDK; skipping request wrapping.");
+            var owners = provider[WRAPPED_REQUEST_OWNER_SYMBOL];
+            if (!Array.isArray(owners)) {
+                // A wrapper without its owner list cannot be taken over, and
+                // claiming success would silence every request event.
+                logger.warn("wrapped without owner list; cannot rebind");
+                return false;
+            }
+            var idx = owners.indexOf(this);
+            if (idx !== -1)
+                owners.splice(idx, 1);
+            owners.push(this);
+            this.wrappedProviders.add(provider);
+            logger.info("Provider already wrapped; rebinding the wrapper to this instance.");
             return true;
         }
         var request = provider.request.bind(provider);
         var wrappedRequest = function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+            var owners, liveOwner;
+            var method = _b.method, params = _b.params;
+            return __generator(this, function (_c) {
+                owners = provider[WRAPPED_REQUEST_OWNER_SYMBOL];
+                if (dispatchInFlight.has(provider)) {
+                    // An outer Formo wrapper is already instrumenting this very
+                    // request; this layer only forwards.
+                    return [2 /*return*/, request({ method: method, params: params })];
+                }
+                liveOwner = Array.isArray(owners)
+                    ? __spreadArray([], owners, true).reverse().find(function (o) { return !o.disposed; })
+                    : undefined;
+                dispatchInFlight.add(provider);
+                try {
+                    return [2 /*return*/, (liveOwner !== null && liveOwner !== void 0 ? liveOwner : this).dispatchWrappedRequest({ method: method, params: params }, provider, request)];
+                }
+                finally {
+                    // Cleared as soon as the dispatch call RETURNS its promise: the
+                    // underlying request has been issued synchronously by then, so
+                    // the window covers exactly the nested layers of this one call
+                    // and never a concurrent request.
+                    dispatchInFlight.delete(provider);
+                }
+                return [2 /*return*/];
+            });
+        }); };
+        try {
+            // MERGE with any existing list rather than overwriting: a wallet that
+            // replaced `request` forces a re-wrap, and discarding the prior list
+            // would drop other live instances from ownership - the newest-live
+            // fallback then has nobody to fall back to.
+            var slot = provider;
+            var prior = slot[WRAPPED_REQUEST_OWNER_SYMBOL];
+            var owners = Array.isArray(prior) ? prior : [];
+            var idx = owners.indexOf(this);
+            if (idx !== -1)
+                owners.splice(idx, 1);
+            owners.push(this);
+            if (!Array.isArray(prior)) {
+                slot[WRAPPED_REQUEST_OWNER_SYMBOL] = owners;
+            }
+            this.wrappedProviders.add(provider);
+        }
+        catch (_a) {
+            /* frozen provider: the request write below fails too and aborts */
+        }
+        return this.installWrappedRequest(provider, wrappedRequest);
+    };
+    /** Install the wrapper function onto the provider; separated so the
+     * routing shim above stays small. */
+    EvmRequestTracker.prototype.installWrappedRequest = function (provider, wrappedRequest) {
+        // Mark the wrapper so we can detect if request is replaced externally and keep a reference on provider
+        wrappedRequest[WRAPPED_REQUEST_SYMBOL] = true;
+        // Both writes go inside the try. A frozen or non-extensible provider
+        // throws on the symbol assignment just as readily as on `request`, and
+        // that one used to sit outside the guard, so an unwrappable provider
+        // aborted registration instead of being skipped.
+        try {
+            provider[WRAPPED_REQUEST_REF_SYMBOL] =
+                wrappedRequest;
+            provider.request = wrappedRequest;
+            // Read back: an accessor or Proxy can ACCEPT the assignment without
+            // installing it, and success here is a promise that capture works.
+            if (provider.request !== wrappedRequest) {
+                logger.warn("request assignment swallowed; not wrapped");
+                return false;
+            }
+            return true;
+        }
+        catch (e) {
+            logger.warn("Failed to wrap provider.request; skipping", e);
+            return false;
+        }
+    };
+    /**
+     * The wrapper body proper: everything a request observation does, run
+     * against THIS instance's registry, wallet state, and event queue. Kept
+     * as a method so a surviving wrapper installed by a previous SDK
+     * instance can hand calls to the current one.
+     */
+    EvmRequestTracker.prototype.dispatchWrappedRequest = function (_a, provider_1, request_1) {
+        return __awaiter(this, arguments, void 0, function (_b, provider, request) {
             var generation_1, responsePromise, capturedChainId_1, response_1, error_1, rpcError, txPromise, txChainId_1, transactionHash_1, error_2, rpcError;
             var _this = this;
+            var _c, _d, _e, _f;
             var method = _b.method, params = _b.params;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            return __generator(this, function (_g) {
+                switch (_g.label) {
                     case 0:
                         // Learn the chain from a call the APP was making anyway.
                         //
@@ -184,6 +322,10 @@ var EvmRequestTracker = /** @class */ (function () {
                             logger.debug("Signature event skipped (autocapture.signature: false)", { method: method });
                             return [2 /*return*/, request({ method: method, params: params })];
                         }
+                        if ((_d = (_c = this.deps).shouldSkipRequestCapture) === null || _d === void 0 ? void 0 : _d.call(_c, method, params)) {
+                            // A pending wagmi mutation owns this capture.
+                            return [2 /*return*/, request({ method: method, params: params })];
+                        }
                         responsePromise = request({ method: method, params: params });
                         // Attach a no-op handler now so a rejection arriving before the await
                         // below is never reported as unhandled. The real handling is there.
@@ -196,7 +338,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                 switch (_a.label) {
                                     case 0:
                                         _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.deps.signature(__assign({ status: SignatureStatus.REQUESTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)))];
+                                        return [4 /*yield*/, this.deps.signature(__assign({ status: SignatureStatus.REQUESTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)), this.attributionFor(provider))];
                                     case 1:
                                         _a.sent();
                                         return [3 /*break*/, 3];
@@ -208,12 +350,12 @@ var EvmRequestTracker = /** @class */ (function () {
                                 }
                             });
                         }); })();
-                        _c.label = 1;
+                        _g.label = 1;
                     case 1:
-                        _c.trys.push([1, 3, , 4]);
+                        _g.trys.push([1, 3, , 4]);
                         return [4 /*yield*/, responsePromise];
                     case 2:
-                        response_1 = _c.sent();
+                        response_1 = _g.sent();
                         // Track signature confirmation only for truthy responses
                         if (response_1) {
                             (function () { return __awaiter(_this, void 0, void 0, function () {
@@ -222,7 +364,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                     switch (_a.label) {
                                         case 0:
                                             _a.trys.push([0, 2, , 3]);
-                                            return [4 /*yield*/, this.deps.signature(__assign({ status: SignatureStatus.CONFIRMED }, this.buildSignatureEventPayload(method, params, response_1, capturedChainId_1, provider)))];
+                                            return [4 /*yield*/, this.deps.signature(__assign({ status: SignatureStatus.CONFIRMED }, this.buildSignatureEventPayload(method, params, response_1, capturedChainId_1, provider)), this.attributionFor(provider))];
                                         case 1:
                                             _a.sent();
                                             return [3 /*break*/, 3];
@@ -237,9 +379,9 @@ var EvmRequestTracker = /** @class */ (function () {
                         }
                         return [2 /*return*/, response_1];
                     case 3:
-                        error_1 = _c.sent();
+                        error_1 = _g.sent();
                         rpcError = error_1;
-                        if ((rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
+                        if (isUserRejectionError(rpcError)) {
                             // Use the already cast rpcError to avoid duplication
                             (function () { return __awaiter(_this, void 0, void 0, function () {
                                 var e_3;
@@ -247,7 +389,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                     switch (_a.label) {
                                         case 0:
                                             _a.trys.push([0, 2, , 3]);
-                                            return [4 /*yield*/, this.deps.signature(__assign({ status: SignatureStatus.REJECTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)))];
+                                            return [4 /*yield*/, this.deps.signature(__assign({ status: SignatureStatus.REJECTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)), this.attributionFor(provider))];
                                         case 1:
                                             _a.sent();
                                             return [3 /*break*/, 3];
@@ -279,6 +421,10 @@ var EvmRequestTracker = /** @class */ (function () {
                             logger.debug("Transaction event skipped (autocapture.transaction: false)", { method: method });
                             return [2 /*return*/, request({ method: method, params: params })];
                         }
+                        if ((_f = (_e = this.deps).shouldSkipRequestCapture) === null || _f === void 0 ? void 0 : _f.call(_e, method, params)) {
+                            // A pending wagmi mutation owns this capture.
+                            return [2 /*return*/, request({ method: method, params: params })];
+                        }
                         txPromise = request({ method: method, params: params });
                         txPromise.catch(function () { return undefined; });
                         txChainId_1 = this.registry.resolveChainId(provider);
@@ -291,7 +437,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                         return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
                                     case 1:
                                         payload = _a.sent();
-                                        return [4 /*yield*/, this.deps.transaction(__assign({ status: TransactionStatus.STARTED }, payload))];
+                                        return [4 /*yield*/, this.deps.transaction(__assign({ status: TransactionStatus.STARTED }, payload), this.attributionFor(provider))];
                                     case 2:
                                         _a.sent();
                                         return [3 /*break*/, 4];
@@ -303,12 +449,12 @@ var EvmRequestTracker = /** @class */ (function () {
                                 }
                             });
                         }); })();
-                        _c.label = 5;
+                        _g.label = 5;
                     case 5:
-                        _c.trys.push([5, 7, , 8]);
+                        _g.trys.push([5, 7, , 8]);
                         return [4 /*yield*/, txPromise];
                     case 6:
-                        transactionHash_1 = _c.sent();
+                        transactionHash_1 = _g.sent();
                         (function () { return __awaiter(_this, void 0, void 0, function () {
                             var payload, e_5;
                             return __generator(this, function (_a) {
@@ -318,7 +464,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                         return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
                                     case 1:
                                         payload = _a.sent();
-                                        return [4 /*yield*/, this.deps.transaction(__assign(__assign({ status: TransactionStatus.BROADCASTED }, payload), { transactionHash: transactionHash_1 }))];
+                                        return [4 /*yield*/, this.deps.transaction(__assign(__assign({ status: TransactionStatus.BROADCASTED }, payload), { transactionHash: transactionHash_1 }), this.attributionFor(provider))];
                                     case 2:
                                         _a.sent();
                                         // Start async polling for transaction receipt
@@ -334,9 +480,9 @@ var EvmRequestTracker = /** @class */ (function () {
                         }); })();
                         return [2 /*return*/, transactionHash_1];
                     case 7:
-                        error_2 = _c.sent();
+                        error_2 = _g.sent();
                         rpcError = error_2;
-                        if ((rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
+                        if (isUserRejectionError(rpcError)) {
                             // Use the already cast rpcError to avoid duplication
                             (function () { return __awaiter(_this, void 0, void 0, function () {
                                 var payload, e_6;
@@ -347,7 +493,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                             return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
                                         case 1:
                                             payload = _a.sent();
-                                            return [4 /*yield*/, this.deps.transaction(__assign({ status: TransactionStatus.REJECTED }, payload))];
+                                            return [4 /*yield*/, this.deps.transaction(__assign({ status: TransactionStatus.REJECTED }, payload), this.attributionFor(provider))];
                                         case 2:
                                             _a.sent();
                                             return [3 /*break*/, 4];
@@ -364,23 +510,19 @@ var EvmRequestTracker = /** @class */ (function () {
                     case 8: return [2 /*return*/, request({ method: method, params: params })];
                 }
             });
-        }); };
-        // Mark the wrapper so we can detect if request is replaced externally and keep a reference on provider
-        wrappedRequest[WRAPPED_REQUEST_SYMBOL] = true;
-        // Both writes go inside the try. A frozen or non-extensible provider
-        // throws on the symbol assignment just as readily as on `request`, and
-        // that one used to sit outside the guard, so an unwrappable provider
-        // aborted registration instead of being skipped.
-        try {
-            provider[WRAPPED_REQUEST_REF_SYMBOL] =
-                wrappedRequest;
-            provider.request = wrappedRequest;
-            return true;
-        }
-        catch (e) {
-            logger.warn("Failed to wrap provider.request; skipping", e);
-            return false;
-        }
+        });
+    };
+    /**
+     * Wallet attribution for request-derived events.
+     *
+     * Live per read through the registry, so a WalletConnect session names
+     * its actual signer ("MetaMask Wallet", "Ledger Live") - the live-test
+     * rows had provider_name EMPTY on every signature and transaction, which
+     * made per-wallet activity unanswerable in the warehouse.
+     */
+    EvmRequestTracker.prototype.attributionFor = function (provider) {
+        var info = this.registry.infoFor(provider);
+        return { providerName: info.name, rdns: info.rdns };
     };
     EvmRequestTracker.prototype.buildSignatureEventPayload = function (method, params, 
     // Intentionally not read. Kept for positional call-site arity.
@@ -476,7 +618,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                     // status: 1 = success, 0 = reverted
                                     if (receipt.status === "0x1" || receipt.status === 1) {
                                         this.deps
-                                            .transaction(__assign(__assign({ status: TransactionStatus.CONFIRMED }, payload), { transactionHash: transactionHash }))
+                                            .transaction(__assign(__assign({ status: TransactionStatus.CONFIRMED }, payload), { transactionHash: transactionHash }), this.attributionFor(provider))
                                             .catch(function (e) {
                                             return logger.error("Formo: Failed to track transaction confirmation", e);
                                         });
@@ -484,7 +626,7 @@ var EvmRequestTracker = /** @class */ (function () {
                                     }
                                     else if (receipt.status === "0x0" || receipt.status === 0) {
                                         this.deps
-                                            .transaction(__assign(__assign({ status: TransactionStatus.REVERTED }, payload), { transactionHash: transactionHash }))
+                                            .transaction(__assign(__assign({ status: TransactionStatus.REVERTED }, payload), { transactionHash: transactionHash }), this.attributionFor(provider))
                                             .catch(function (e) {
                                             return logger.error("Formo: Failed to track transaction revert", e);
                                         });
@@ -527,10 +669,10 @@ var EvmRequestTracker = /** @class */ (function () {
      */
     EvmRequestTracker.prototype.trackBatchedCalls = function (provider, request, params) {
         return __awaiter(this, void 0, void 0, function () {
-            var sendPromise, batch, calls, declared, chainId, address, payloads, _i, payloads_1, p, properties, rest, result, batchId, _a, payloads_2, p, properties, rest, error_3, rpcError, _b, payloads_3, p, properties, rest;
-            var _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var sendPromise, batch, calls, declared, chainId, address, attribution, payloads, _i, payloads_1, p, properties, rest, result, batchId, _a, payloads_2, p, properties, rest, error_3, rpcError, _b, payloads_3, p, properties, rest;
+            var _c, _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
                         if (!this.deps.isAutocaptureEnabled("transaction")) {
                             logger.debug("Transaction event skipped (autocapture.transaction: false)", {
@@ -538,13 +680,17 @@ var EvmRequestTracker = /** @class */ (function () {
                             });
                             return [2 /*return*/, request({ method: "wallet_sendCalls", params: params })];
                         }
+                        if ((_d = (_c = this.deps).shouldSkipRequestCapture) === null || _d === void 0 ? void 0 : _d.call(_c, "wallet_sendCalls", params)) {
+                            // A pending wagmi sendCalls mutation owns this capture.
+                            return [2 /*return*/, request({ method: "wallet_sendCalls", params: params })];
+                        }
                         sendPromise = request({ method: "wallet_sendCalls", params: params });
                         sendPromise.catch(function () { return undefined; });
                         batch = params[0];
                         calls = Array.isArray(batch === null || batch === void 0 ? void 0 : batch.calls) ? batch.calls : [];
                         declared = typeof (batch === null || batch === void 0 ? void 0 : batch.chainId) === "string" ? parseChainId(batch.chainId) : undefined;
                         chainId = declared || this.registry.resolveChainId(provider);
-                        address = validateAndChecksumAddress((_c = batch === null || batch === void 0 ? void 0 : batch.from) !== null && _c !== void 0 ? _c : "");
+                        address = validateAndChecksumAddress((_e = batch === null || batch === void 0 ? void 0 : batch.from) !== null && _e !== void 0 ? _e : "");
                         if (!address) {
                             // Nothing can be attributed without a sender, and inventing one would
                             // be worse than reporting nothing. The user's call still goes through.
@@ -563,16 +709,14 @@ var EvmRequestTracker = /** @class */ (function () {
                         if (!provider || provider === this.wallet.provider || !this.wallet.provider) {
                             this.wallet.backfill(address, chainId, provider);
                         }
+                        attribution = this.attributionFor(provider);
                         payloads = calls.map(function (call, index) { return ({
                             chainId: chainId,
                             address: address,
                             to: call === null || call === void 0 ? void 0 : call.to,
                             value: call === null || call === void 0 ? void 0 : call.value,
                             data: call === null || call === void 0 ? void 0 : call.data,
-                            properties: {
-                                batch_size: calls.length,
-                                batch_index: index,
-                            },
+                            properties: __assign({ batch_size: calls.length, batch_index: index }, attribution),
                         }); });
                         // STARTED carries no batch id: the wallet has not issued one yet, exactly
                         // as `eth_sendTransaction` has no hash at this point. Position within the
@@ -584,12 +728,12 @@ var EvmRequestTracker = /** @class */ (function () {
                                 .transaction(__assign({ status: TransactionStatus.STARTED }, rest), properties)
                                 .catch(function (e) { return logger.error("Formo: Failed to track batch call start", e); });
                         }
-                        _d.label = 1;
+                        _f.label = 1;
                     case 1:
-                        _d.trys.push([1, 3, , 4]);
+                        _f.trys.push([1, 3, , 4]);
                         return [4 /*yield*/, sendPromise];
                     case 2:
-                        result = _d.sent();
+                        result = _f.sent();
                         batchId = readBatchId(result);
                         for (_a = 0, payloads_2 = payloads; _a < payloads_2.length; _a++) {
                             p = payloads_2[_a];
@@ -604,9 +748,9 @@ var EvmRequestTracker = /** @class */ (function () {
                             this.pollBatchStatus(provider, batchId, payloads);
                         return [2 /*return*/, result];
                     case 3:
-                        error_3 = _d.sent();
+                        error_3 = _f.sent();
                         rpcError = error_3;
-                        if ((rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
+                        if (isUserRejectionError(rpcError)) {
                             // One rejection dismisses the whole prompt, so every call in it is
                             // rejected. Reporting only the first would undercount.
                             for (_b = 0, payloads_3 = payloads; _b < payloads_3.length; _b++) {

package/dist/esm/src/provider/detection.d.ts

@@ -41,6 +41,36 @@ export interface ProviderInfo {
  * ```
  */
 export declare function detectInjectedProviderInfo(provider: EIP1193Provider): ProviderInfo;
+/**
+ * Was this error the USER declining, whatever transport delivered it?
+ *
+ * Three dialects say "the user said no":
+ * - EIP-1193: code 4001 (UserRejectedRequest).
+ * - WalletConnect sdkErrors: codes 5000-5005 (USER_REJECTED and its
+ *   variants). A LIVE MetaMask Mobile session rejecting a transaction
+ *   produced one of these and the SDK's 4001-only match reported nothing -
+ *   every WalletConnect rejection was silently uncounted.
+ * - viem: a typed UserRejectedRequestError, sometimes without the numeric
+ *   code surviving the wrapping.
+ *
+ * The real code often hides under `cause` (viem nests, WC wraps), so the
+ * chain is walked a few levels.
+ */
+export declare function isUserRejectionError(error: unknown): boolean;
+/**
+ * The wallet on the far side of a WalletConnect session.
+ *
+ * WalletConnect is a transport, not a wallet: the signing wallet (Ledger
+ * Live, MetaMask Mobile, Safe, ...) identifies itself in the session's peer
+ * metadata. Reporting only "WalletConnect" hides every wallet behind it -
+ * production showed Ledger at effectively zero while its sessions were being
+ * tracked under the transport's name. Reads synchronous state only; never
+ * issues an RPC.
+ */
+export declare function readWalletConnectPeer(provider: EIP1193Provider): {
+    name: string;
+    url?: string;
+} | undefined;
 /**
  * Validates that a provider implements the required EIP-1193 interface
  *

package/dist/esm/src/provider/detection.js

@@ -1,6 +1,17 @@
 /**
  * Provider detection utilities for identifying wallet providers
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 /**
  * Default icon for providers without custom icons
  */
@@ -76,6 +87,55 @@ export function detectInjectedProviderInfo(provider) {
         icon: DEFAULT_PROVIDER_ICON,
     };
 }
+/**
+ * Was this error the USER declining, whatever transport delivered it?
+ *
+ * Three dialects say "the user said no":
+ * - EIP-1193: code 4001 (UserRejectedRequest).
+ * - WalletConnect sdkErrors: codes 5000-5005 (USER_REJECTED and its
+ *   variants). A LIVE MetaMask Mobile session rejecting a transaction
+ *   produced one of these and the SDK's 4001-only match reported nothing -
+ *   every WalletConnect rejection was silently uncounted.
+ * - viem: a typed UserRejectedRequestError, sometimes without the numeric
+ *   code surviving the wrapping.
+ *
+ * The real code often hides under `cause` (viem nests, WC wraps), so the
+ * chain is walked a few levels.
+ */
+export function isUserRejectionError(error) {
+    var cursor = error;
+    for (var depth = 0; cursor && depth < 5; depth++) {
+        var code = cursor.code;
+        if (code === 4001 ||
+            (typeof code === "number" && code >= 5000 && code <= 5005) ||
+            cursor.name === "UserRejectedRequestError") {
+            return true;
+        }
+        cursor = cursor.cause;
+    }
+    return false;
+}
+/**
+ * The wallet on the far side of a WalletConnect session.
+ *
+ * WalletConnect is a transport, not a wallet: the signing wallet (Ledger
+ * Live, MetaMask Mobile, Safe, ...) identifies itself in the session's peer
+ * metadata. Reporting only "WalletConnect" hides every wallet behind it -
+ * production showed Ledger at effectively zero while its sessions were being
+ * tracked under the transport's name. Reads synchronous state only; never
+ * issues an RPC.
+ */
+export function readWalletConnectPeer(provider) {
+    var _a;
+    var session = provider.session;
+    var metadata = (_a = session === null || session === void 0 ? void 0 : session.peer) === null || _a === void 0 ? void 0 : _a.metadata;
+    if (!metadata || typeof metadata.name !== "string" || metadata.name.length === 0) {
+        return undefined;
+    }
+    return __assign({ name: metadata.name }, (typeof metadata.url === "string" && metadata.url.length > 0
+        ? { url: metadata.url }
+        : {}));
+}
 /**
  * Validates that a provider implements the required EIP-1193 interface
  *

package/dist/esm/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/esm/src/provider/index.js

@@ -1,5 +1,5 @@
 /**
  * Provider-related exports
  */
-export { detectInjectedProviderInfo, isValidProvider, DEFAULT_PROVIDER_ICON, } from './detection';
+export { detectInjectedProviderInfo, isValidProvider, readWalletConnectPeer, isUserRejectionError, DEFAULT_PROVIDER_ICON, } from './detection';
 //# sourceMappingURL=index.js.map