@formo/analytics 1.35.2 → 1.37.0

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

@@ -0,0 +1,710 @@
+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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { logger } from "../logger";
+import { parseChainId } from "../utils/chain";
+import { validateAndChecksumAddress } from "../utils/address";
+import { SignatureStatus, TransactionStatus, WRAPPED_REQUEST_SYMBOL, WRAPPED_REQUEST_REF_SYMBOL, } from "../types";
+import { readBatchId, readBatchStatusCode, batchCallOutcome, batchReceiptForCall, } from "./batch";
+/**
+ * Decode a hex-encoded `personal_sign` message.
+ *
+ * Deliberately not `Buffer.from(hex, "hex")`. `Buffer` is a Node global with
+ * no polyfill in this bundle, so in a browser that line threw and the
+ * signature event was dropped with it - silently, which is the worst way for
+ * analytics to fail. `TextDecoder` is available everywhere this SDK runs, and
+ * `TextEncoder` is already used elsewhere in the queue.
+ *
+ * Malformed input decodes to as much as can be read rather than throwing: a
+ * message we cannot fully read is still worth reporting the signature for.
+ */
+function hexToUtf8(hex) {
+    var clean = typeof hex === "string" && hex.startsWith("0x") ? hex.slice(2) : hex;
+    if (typeof clean !== "string" || clean.length === 0)
+        return "";
+    var byteCount = Math.floor(clean.length / 2);
+    var bytes = new Uint8Array(byteCount);
+    for (var i = 0; i < byteCount; i++) {
+        var byte = Number.parseInt(clean.substring(i * 2, i * 2 + 2), 16);
+        if (Number.isNaN(byte))
+            return new TextDecoder().decode(bytes.subarray(0, i));
+        bytes[i] = byte;
+    }
+    return new TextDecoder().decode(bytes);
+}
+/**
+ * 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.
+ */
+var EvmRequestTracker = /** @class */ (function () {
+    function EvmRequestTracker(wallet, registry, deps) {
+        this.wallet = wallet;
+        this.registry = registry;
+        this.deps = deps;
+        /**
+         * Timers for receipt and batch-status polling.
+         *
+         * A poll re-arms for up to thirty seconds, so a torn-down instance would
+         * otherwise keep asking a wallet about transactions nobody is listening
+         * for, and hold the process open for the whole window. That is the same
+         * shape as the batch timer that hung the test suite in #338.
+         */
+        this.polls = new Set();
+        this.disposed = false;
+    }
+    /** Stop every poll in flight. Terminal, like the event queue's close(). */
+    EvmRequestTracker.prototype.cleanup = function () {
+        this.disposed = true;
+        this.polls.forEach(function (timer) { return clearTimeout(timer); });
+        this.polls.clear();
+    };
+    /** Re-arm a poll, unless this tracker has been torn down. */
+    EvmRequestTracker.prototype.schedulePoll = function (fn, delayMs) {
+        var _this = this;
+        if (this.disposed)
+            return;
+        var timer = setTimeout(function () {
+            _this.polls.delete(timer);
+            fn();
+        }, delayMs);
+        this.polls.add(timer);
+    };
+    /**
+     * Wrap a provider's `request`. Returns whether the wrapper is installed:
+     * a caller that marks the provider as tracked on a false return would
+     * never retry it, and every signature and transaction from that wallet
+     * would be missed for the rest of the session.
+     */
+    EvmRequestTracker.prototype.registerRequestListeners = function (provider) {
+        var _this = this;
+        logger.info("registerRequestListeners");
+        if (!provider) {
+            logger.error("Provider not found for request (signature, transaction) tracking");
+            return false;
+        }
+        // Check if the provider is already wrapped with our SDK's wrapper
+        var currentRequest = provider.request;
+        if (this.registry.isWrapped(provider, currentRequest)) {
+            logger.info("Provider already wrapped with our SDK; skipping request wrapping.");
+            return true;
+        }
+        var request = provider.request.bind(provider);
+        var wrappedRequest = function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+            var generation_1, responsePromise, capturedChainId_1, response_1, error_1, rpcError, txPromise, txChainId_1, transactionHash_1, error_2, rpcError;
+            var _this = this;
+            var method = _b.method, params = _b.params;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        // Learn the chain from a call the APP was making anyway.
+                        //
+                        // A standards-compliant provider need not expose a synchronous `chainId`
+                        // property, and if it connected before the SDK initialised, its
+                        // `connect` event is never replayed. Such a provider stayed unknown -
+                        // reported as chain 0, and with `excludeChains` configured its events
+                        // were dropped even on an allowed chain. This adds no request of its
+                        // own; it only reads the answer to one the dapp already sent.
+                        if (method === "eth_chainId") {
+                            generation_1 = this.registry.chainGeneration(provider);
+                            return [2 /*return*/, request({ method: method, params: params }).then(function (result) {
+                                    // A `chainChanged` for THIS provider may have landed while this was
+                                    // in flight. It is newer by definition, so it must not be
+                                    // overwritten by this answer.
+                                    if (generation_1 === (_this.registry.chainGeneration(provider)) &&
+                                        typeof result === "string") {
+                                        _this.registry.rememberChain(provider, parseChainId(result));
+                                    }
+                                    return result;
+                                })];
+                        }
+                        if (!(Array.isArray(params) &&
+                            ["eth_signTypedData_v4", "personal_sign"].includes(method))) return [3 /*break*/, 4];
+                        if (!this.deps.isAutocaptureEnabled("signature")) {
+                            logger.debug("Signature event skipped (autocapture.signature: false)", { method: method });
+                            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.
+                        responsePromise.catch(function () { return undefined; });
+                        capturedChainId_1 = this.registry.resolveChainId(provider);
+                        // Fire-and-forget tracking
+                        (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var e_1;
+                            return __generator(this, function (_a) {
+                                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)))];
+                                    case 1:
+                                        _a.sent();
+                                        return [3 /*break*/, 3];
+                                    case 2:
+                                        e_1 = _a.sent();
+                                        logger.error("Formo: Failed to track signature request", e_1);
+                                        return [3 /*break*/, 3];
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        }); })();
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, responsePromise];
+                    case 2:
+                        response_1 = _c.sent();
+                        // Track signature confirmation only for truthy responses
+                        if (response_1) {
+                            (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var e_2;
+                                return __generator(this, function (_a) {
+                                    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)))];
+                                        case 1:
+                                            _a.sent();
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            e_2 = _a.sent();
+                                            logger.error("Formo: Failed to track signature confirmation", e_2);
+                                            return [3 /*break*/, 3];
+                                        case 3: return [2 /*return*/];
+                                    }
+                                });
+                            }); })();
+                        }
+                        return [2 /*return*/, response_1];
+                    case 3:
+                        error_1 = _c.sent();
+                        rpcError = error_1;
+                        if ((rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
+                            // Use the already cast rpcError to avoid duplication
+                            (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var e_3;
+                                return __generator(this, function (_a) {
+                                    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)))];
+                                        case 1:
+                                            _a.sent();
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            e_3 = _a.sent();
+                                            logger.error("Formo: Failed to track signature rejection", e_3);
+                                            return [3 /*break*/, 3];
+                                        case 3: return [2 /*return*/];
+                                    }
+                                });
+                            }); })();
+                        }
+                        throw error_1;
+                    case 4:
+                        // Handle EIP-5792 batched calls.
+                        //
+                        // Smart accounts send through `wallet_sendCalls` rather than
+                        // `eth_sendTransaction`, and until now the SDK understood only the
+                        // latter: those transactions were not captured at all, silently. That
+                        // is the same failure shape as the missing-connect bug that started
+                        // this work - nothing errors, the data is simply absent.
+                        if (method === "wallet_sendCalls" && Array.isArray(params) && params[0]) {
+                            return [2 /*return*/, this.trackBatchedCalls(provider, request, params)];
+                        }
+                        if (!(Array.isArray(params) &&
+                            method === "eth_sendTransaction" &&
+                            params[0])) return [3 /*break*/, 8];
+                        if (!this.deps.isAutocaptureEnabled("transaction")) {
+                            logger.debug("Transaction event skipped (autocapture.transaction: false)", { method: method });
+                            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);
+                        (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var payload, e_4;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 3, , 4]);
+                                        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))];
+                                    case 2:
+                                        _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        e_4 = _a.sent();
+                                        logger.error("Formo: Failed to track transaction start", e_4);
+                                        return [3 /*break*/, 4];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); })();
+                        _c.label = 5;
+                    case 5:
+                        _c.trys.push([5, 7, , 8]);
+                        return [4 /*yield*/, txPromise];
+                    case 6:
+                        transactionHash_1 = _c.sent();
+                        (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var payload, e_5;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 3, , 4]);
+                                        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 }))];
+                                    case 2:
+                                        _a.sent();
+                                        // Start async polling for transaction receipt
+                                        this.pollTransactionReceipt(provider, transactionHash_1, payload);
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        e_5 = _a.sent();
+                                        logger.error("Formo: Failed to track transaction broadcast", e_5);
+                                        return [3 /*break*/, 4];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); })();
+                        return [2 /*return*/, transactionHash_1];
+                    case 7:
+                        error_2 = _c.sent();
+                        rpcError = error_2;
+                        if ((rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
+                            // Use the already cast rpcError to avoid duplication
+                            (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var payload, e_6;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 3, , 4]);
+                                            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))];
+                                        case 2:
+                                            _a.sent();
+                                            return [3 /*break*/, 4];
+                                        case 3:
+                                            e_6 = _a.sent();
+                                            logger.error("Formo: Failed to track transaction rejection", e_6);
+                                            return [3 /*break*/, 4];
+                                        case 4: return [2 /*return*/];
+                                    }
+                                });
+                            }); })();
+                        }
+                        throw error_2;
+                    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;
+        }
+    };
+    EvmRequestTracker.prototype.buildSignatureEventPayload = function (method, params, 
+    // Intentionally not read. Kept for positional call-site arity.
+    _response, chainId, provider) {
+        var _a;
+        var rawAddress = method === "personal_sign"
+            ? params[1]
+            : params[0];
+        var validAddress = validateAndChecksumAddress(rawAddress);
+        if (!validAddress) {
+            throw new Error("Invalid address in signature payload: ".concat(rawAddress));
+        }
+        var effectiveChainId = (_a = chainId !== null && chainId !== void 0 ? chainId : this.wallet.evmChainId) !== null && _a !== void 0 ? _a : undefined;
+        // Only the active provider may write central wallet state - see the same
+        // guard in buildTransactionEventPayload.
+        if (!provider || provider === this.wallet.provider || !this.wallet.provider) {
+            this.wallet.backfill(validAddress, effectiveChainId, provider);
+        }
+        var basePayload = {
+            chainId: effectiveChainId,
+            address: validAddress,
+        };
+        if (method === "personal_sign") {
+            return __assign(__assign({}, basePayload), { message: hexToUtf8(params[0]) });
+        }
+        // eth_signTypedData*: params[1] is the full EIP-712 struct.
+        return __assign(__assign({}, basePayload), { message: params[1] });
+    };
+    EvmRequestTracker.prototype.buildTransactionEventPayload = function (params, provider, 
+    /**
+     * Chain resolved once for this request's whole lifecycle. Passing it keeps
+     * every status of one transaction on the same chain even if the user
+     * switches network while the wallet prompt is open.
+     */
+    capturedChainId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, data, from, to, value, validAddress, chainId;
+            return __generator(this, function (_b) {
+                _a = params[0], data = _a.data, from = _a.from, to = _a.to, value = _a.value;
+                validAddress = validateAndChecksumAddress(from);
+                if (!validAddress) {
+                    throw new Error("Invalid address in transaction payload: ".concat(from));
+                }
+                chainId = capturedChainId !== null && capturedChainId !== void 0 ? capturedChainId : this.registry.resolveChainId(provider);
+                // Only the ACTIVE provider may write central wallet state. A request from
+                // a second, non-active wallet would otherwise overwrite the active
+                // provider's address and chain, and every later request through the active
+                // provider would then trust the other wallet's chain - persistent
+                // mis-attribution, and a way around `excludeChains`.
+                if (!provider || provider === this.wallet.provider || !this.wallet.provider) {
+                    this.wallet.backfill(validAddress, chainId, provider);
+                }
+                return [2 /*return*/, {
+                        chainId: chainId,
+                        data: data,
+                        address: validAddress,
+                        to: to,
+                        value: value,
+                    }];
+            });
+        });
+    };
+    /**
+     * Polls for transaction receipt and emits tx.status = CONFIRMED or REVERTED.
+     */
+    EvmRequestTracker.prototype.pollTransactionReceipt = function (provider_1, transactionHash_2, payload_1) {
+        return __awaiter(this, arguments, void 0, function (provider, transactionHash, payload, maxAttempts, intervalMs) {
+            var attempts, poll;
+            var _this = this;
+            if (maxAttempts === void 0) { maxAttempts = 10; }
+            if (intervalMs === void 0) { intervalMs = 3000; }
+            return __generator(this, function (_a) {
+                attempts = 0;
+                if (!provider)
+                    return [2 /*return*/];
+                poll = function () { return __awaiter(_this, void 0, void 0, function () {
+                    var receipt, e_7;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (this.disposed)
+                                    return [2 /*return*/];
+                                _a.label = 1;
+                            case 1:
+                                _a.trys.push([1, 3, , 4]);
+                                return [4 /*yield*/, provider.request({
+                                        method: "eth_getTransactionReceipt",
+                                        params: [transactionHash],
+                                    })];
+                            case 2:
+                                receipt = (_a.sent());
+                                if (receipt) {
+                                    // status: 1 = success, 0 = reverted
+                                    if (receipt.status === "0x1" || receipt.status === 1) {
+                                        this.deps
+                                            .transaction(__assign(__assign({ status: TransactionStatus.CONFIRMED }, payload), { transactionHash: transactionHash }))
+                                            .catch(function (e) {
+                                            return logger.error("Formo: Failed to track transaction confirmation", e);
+                                        });
+                                        return [2 /*return*/];
+                                    }
+                                    else if (receipt.status === "0x0" || receipt.status === 0) {
+                                        this.deps
+                                            .transaction(__assign(__assign({ status: TransactionStatus.REVERTED }, payload), { transactionHash: transactionHash }))
+                                            .catch(function (e) {
+                                            return logger.error("Formo: Failed to track transaction revert", e);
+                                        });
+                                        return [2 /*return*/];
+                                    }
+                                }
+                                return [3 /*break*/, 4];
+                            case 3:
+                                e_7 = _a.sent();
+                                logger.error("Error polling transaction receipt", e_7);
+                                return [3 /*break*/, 4];
+                            case 4:
+                                attempts++;
+                                if (attempts < maxAttempts)
+                                    this.schedulePoll(poll, intervalMs);
+                                return [2 /*return*/];
+                        }
+                    });
+                }); };
+                poll();
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * One `transaction` event per call in an EIP-5792 batch.
+     *
+     * 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
+     * per-call receipts say otherwise on a non-atomic batch.
+     */
+    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) {
+                    case 0:
+                        if (!this.deps.isAutocaptureEnabled("transaction")) {
+                            logger.debug("Transaction event skipped (autocapture.transaction: false)", {
+                                method: "wallet_sendCalls",
+                            });
+                            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 : "");
+                        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.
+                            logger.warn("Formo: wallet_sendCalls has no valid `from`; not tracking", {
+                                from: batch === null || batch === void 0 ? void 0 : batch.from,
+                            });
+                            return [2 /*return*/, sendPromise];
+                        }
+                        if (calls.length === 0) {
+                            logger.debug("Formo: wallet_sendCalls carried no calls");
+                            return [2 /*return*/, sendPromise];
+                        }
+                        // Only the ACTIVE provider may write central wallet state, for the same
+                        // reason as the single-transaction path: a second wallet would otherwise
+                        // overwrite the active provider's address and chain.
+                        if (!provider || provider === this.wallet.provider || !this.wallet.provider) {
+                            this.wallet.backfill(address, chainId, 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,
+                            },
+                        }); });
+                        // 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
+                        // batch is known, and is what groups these until the id arrives.
+                        for (_i = 0, payloads_1 = payloads; _i < payloads_1.length; _i++) {
+                            p = payloads_1[_i];
+                            properties = p.properties, rest = __rest(p, ["properties"]);
+                            this.deps
+                                .transaction(__assign({ status: TransactionStatus.STARTED }, rest), properties)
+                                .catch(function (e) { return logger.error("Formo: Failed to track batch call start", e); });
+                        }
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, sendPromise];
+                    case 2:
+                        result = _d.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"]);
+                            this.deps
+                                .transaction(__assign({ status: TransactionStatus.BROADCASTED }, rest), __assign(__assign({}, properties), (batchId ? { batch_id: batchId } : {})))
+                                .catch(function (e) {
+                                return logger.error("Formo: Failed to track batch call broadcast", e);
+                            });
+                        }
+                        if (batchId)
+                            this.pollBatchStatus(provider, batchId, payloads);
+                        return [2 /*return*/, result];
+                    case 3:
+                        error_3 = _d.sent();
+                        rpcError = error_3;
+                        if ((rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
+                            // 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++) {
+                                p = payloads_3[_b];
+                                properties = p.properties, rest = __rest(p, ["properties"]);
+                                this.deps
+                                    .transaction(__assign({ status: TransactionStatus.REJECTED }, rest), properties)
+                                    .catch(function (e) {
+                                    return logger.error("Formo: Failed to track batch call rejection", e);
+                                });
+                            }
+                        }
+                        throw error_3;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Resolve a batch through `wallet_getCallsStatus`.
+     *
+     * The status codes are EIP-5792's: 100 pending, 200 confirmed, 400 failed
+     * before landing, 500 reverted, 600 partially reverted. Anything below 200
+     * means keep waiting.
+     *
+     * A per-call receipt wins over the batch verdict where one exists, which is
+     * what makes a partially reverted non-atomic batch report honestly instead
+     * of marking every call with the batch's worst outcome.
+     */
+    EvmRequestTracker.prototype.pollBatchStatus = function (provider_1, batchId_1, payloads_4) {
+        return __awaiter(this, arguments, void 0, function (provider, batchId, payloads, maxAttempts, intervalMs) {
+            var attempts, poll;
+            var _this = this;
+            if (maxAttempts === void 0) { maxAttempts = 10; }
+            if (intervalMs === void 0) { intervalMs = 3000; }
+            return __generator(this, function (_a) {
+                if (!provider)
+                    return [2 /*return*/];
+                attempts = 0;
+                poll = function () { return __awaiter(_this, void 0, void 0, function () {
+                    var res_1, code_1, e_8;
+                    var _this = this;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (this.disposed)
+                                    return [2 /*return*/];
+                                _a.label = 1;
+                            case 1:
+                                _a.trys.push([1, 3, , 4]);
+                                return [4 /*yield*/, provider.request({
+                                        method: "wallet_getCallsStatus",
+                                        params: [batchId],
+                                    })];
+                            case 2:
+                                res_1 = (_a.sent());
+                                code_1 = readBatchStatusCode(res_1);
+                                if (code_1 !== undefined && code_1 >= 200) {
+                                    payloads.forEach(function (p, index) {
+                                        // 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.
+                                        if (outcome === undefined)
+                                            return;
+                                        var properties = p.properties, rest = __rest(p, ["properties"]);
+                                        _this.deps
+                                            .transaction(__assign(__assign({ status: outcome }, rest), ((receipt === null || receipt === void 0 ? void 0 : receipt.transactionHash)
+                                            ? { transactionHash: receipt.transactionHash }
+                                            : {})), __assign(__assign({}, properties), { batch_id: batchId }))
+                                            .catch(function (e) {
+                                            return logger.error("Formo: Failed to track batch call outcome", e);
+                                        });
+                                    });
+                                    return [2 /*return*/];
+                                }
+                                return [3 /*break*/, 4];
+                            case 3:
+                                e_8 = _a.sent();
+                                logger.error("Error polling batch call status", e_8);
+                                return [3 /*break*/, 4];
+                            case 4:
+                                attempts++;
+                                if (attempts < maxAttempts)
+                                    this.schedulePoll(poll, intervalMs);
+                                return [2 /*return*/];
+                        }
+                    });
+                }); };
+                poll();
+                return [2 /*return*/];
+            });
+        });
+    };
+    return EvmRequestTracker;
+}());
+export { EvmRequestTracker };
+//# sourceMappingURL=EvmRequestTracker.js.map