@formo/analytics 1.36.0 → 1.38.0

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

@@ -56,10 +56,21 @@ 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.
  *
@@ -96,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;
@@ -111,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) {
@@ -142,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.
                         //
@@ -183,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.
@@ -195,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];
@@ -207,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 () {
@@ -221,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];
@@ -236,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;
@@ -246,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];
@@ -278,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);
@@ -290,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];
@@ -302,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) {
@@ -317,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
@@ -333,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;
@@ -346,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];
@@ -363,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.
@@ -475,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);
                                         });
@@ -483,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);
                                         });
@@ -511,11 +654,14 @@ var EvmRequestTracker = /** @class */ (function () {
     /**
      * One `transaction` event per call in an EIP-5792 batch.
      *
-     * A batch is not a transaction. It maps to several on-chain transactions,
-     * so reporting it as one event would understate volume and make revenue and
-     * per-contract attribution wrong for every app that adopts smart accounts.
-     * Each call is reported on its own, carrying the batch id so the calls can
-     * be reassembled downstream.
+     * The CALL is the unit of attribution: each has its own target, calldata,
+     * and value, and folding a batch into one event would misattribute revenue
+     * and per-contract activity for every app that adopts smart accounts. How
+     * many on-chain transactions a batch becomes depends on execution - an
+     * atomic batch lands as ONE transaction, a non-atomic fallback as several -
+     * so on-chain volume is `count(distinct transaction_hash)`, wallet actions
+     * `count(distinct batch_id)`, never the event count. Each call is reported
+     * on its own, carrying the batch id so the calls reassemble downstream.
      *
      * Status is per BATCH, because that is what `wallet_getCallsStatus` reports.
      * When it resolves, every call in the batch moves together, except where
@@ -523,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)", {
@@ -534,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.
@@ -559,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
@@ -580,13 +728,13 @@ 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();
-                        batchId = this.readBatchId(result);
+                        result = _f.sent();
+                        batchId = readBatchId(result);
                         for (_a = 0, payloads_2 = payloads; _a < payloads_2.length; _a++) {
                             p = payloads_2[_a];
                             properties = p.properties, rest = __rest(p, ["properties"]);
@@ -600,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++) {
@@ -621,54 +769,6 @@ var EvmRequestTracker = /** @class */ (function () {
             });
         });
     };
-    /**
-     * How one call in a settled batch ended.
-     *
-     * A per-call receipt is authoritative where it exists: that is what makes a
-     * partially reverted non-atomic batch report honestly rather than tarring
-     * every call with the batch's worst outcome. A receipt whose own status is
-     * unreadable falls back to the batch verdict rather than being assumed good.
-     *
-     * The codes are EIP-5792's: 200 confirmed, 400 failed BEFORE landing on
-     * chain, 500 reverted, 600 partially reverted. 400 is a rejection, not a
-     * revert - nothing was mined, so calling it reverted would misreport gas
-     * spent and on-chain activity that never happened.
-     *
-     * Returns undefined when the call cannot be decided, which happens on 600
-     * for a call the wallet gave no receipt for.
-     */
-    EvmRequestTracker.prototype.batchCallOutcome = function (code, receipt) {
-        var receiptStatus = receipt === null || receipt === void 0 ? void 0 : receipt.status;
-        if (receiptStatus !== undefined) {
-            return receiptStatus === "0x0" || receiptStatus === 0
-                ? TransactionStatus.REVERTED
-                : TransactionStatus.CONFIRMED;
-        }
-        if (code >= 600)
-            return undefined;
-        if (code >= 500)
-            return TransactionStatus.REVERTED;
-        if (code >= 400)
-            return TransactionStatus.REJECTED;
-        return TransactionStatus.CONFIRMED;
-    };
-    /**
-     * The batch identifier from a `wallet_sendCalls` result.
-     *
-     * EIP-5792 settled on `{ id }`, but wallets shipped against the earlier
-     * draft return a bare string. Both are accepted so a wallet on either
-     * version is still grouped.
-     */
-    EvmRequestTracker.prototype.readBatchId = function (result) {
-        if (typeof result === "string" && result.length > 0)
-            return result;
-        if (result && typeof result === "object") {
-            var id = result.id;
-            if (typeof id === "string" && id.length > 0)
-                return id;
-        }
-        return undefined;
-    };
     /**
      * Resolve a batch through `wallet_getCallsStatus`.
      *
@@ -691,7 +791,7 @@ var EvmRequestTracker = /** @class */ (function () {
                     return [2 /*return*/];
                 attempts = 0;
                 poll = function () { return __awaiter(_this, void 0, void 0, function () {
-                    var res, code_1, receipts_1, e_8;
+                    var res_1, code_1, e_8;
                     var _this = this;
                     return __generator(this, function (_a) {
                         switch (_a.label) {
@@ -706,13 +806,14 @@ var EvmRequestTracker = /** @class */ (function () {
                                         params: [batchId],
                                     })];
                             case 2:
-                                res = (_a.sent());
-                                code_1 = typeof (res === null || res === void 0 ? void 0 : res.status) === "number" ? res.status : undefined;
+                                res_1 = (_a.sent());
+                                code_1 = readBatchStatusCode(res_1);
                                 if (code_1 !== undefined && code_1 >= 200) {
-                                    receipts_1 = Array.isArray(res === null || res === void 0 ? void 0 : res.receipts) ? res.receipts : [];
                                     payloads.forEach(function (p, index) {
-                                        var receipt = receipts_1[index];
-                                        var outcome = _this.batchCallOutcome(code_1, receipt);
+                                        // Atomic-aware: one receipt covering the whole batch reaches
+                                        // every call, hash included, not just call 0.
+                                        var receipt = batchReceiptForCall(res_1, index, payloads.length);
+                                        var outcome = batchCallOutcome(code_1, receipt);
                                         // 600 means SOME calls reverted, so a call with no receipt of its
                                         // own has not been decided. Reporting it either way would invent
                                         // a result; leaving it unsettled is the honest answer.