@formo/analytics 1.35.2 → 1.37.0

package/dist/esm/src/tracking/TrackingPolicy.js

@@ -0,0 +1,197 @@
+import { getTimezone } from "../utils/timezone";
+import { isLocalhost } from "../validators";
+/**
+ * Every "may we track this?" decision, in one place.
+ *
+ * Split out of `FormoAnalytics` so the rules can be read and tested without
+ * an SDK instance, and so option parsing happens once rather than being
+ * re-derived at each gate.
+ */
+var TrackingPolicy = /** @class */ (function () {
+    function TrackingPolicy(deps) {
+        this.deps = deps;
+    }
+    /**
+     * `tracking` as an options object, or null when it is absent, a boolean, or
+     * anything else. Every exclusion rule lives on the object form, so a null
+     * here means "no exclusions configured", not "excluded".
+     */
+    TrackingPolicy.prototype.trackingOptions = function () {
+        var tracking = this.deps.options().tracking;
+        if (tracking === null ||
+            typeof tracking !== "object" ||
+            Array.isArray(tracking)) {
+            return null;
+        }
+        return tracking;
+    };
+    /**
+     * Visitor-level tracking suppression.
+     *
+     * True when the SDK must not persist any identity/session/chain state or
+     * send any events for this visitor: an explicit opt-out, or a
+     * jurisdiction/timezone/host/path exclusion. Public entry points that write
+     * state before reaching `shouldTrack()` (identify / connect / detect) check
+     * this first, so a suppressed visitor leaves no cookies or session state.
+     */
+    TrackingPolicy.prototype.isTrackingSuppressed = function () {
+        return this.deps.hasOptedOut() || this.isEnvironmentExcluded();
+    };
+    /**
+     * Whether the environment is excluded: the visitor's timezone, the current
+     * hostname, or the current pathname.
+     *
+     * Timezone is visitor-level and stable for the session. Host and path are
+     * current-page-level and transient, so a SPA navigating back to an allowed
+     * path resumes tracking for later actions.
+     */
+    TrackingPolicy.prototype.isEnvironmentExcluded = function () {
+        return (this.isTimezoneExcluded() ||
+            this.isHostExcluded() ||
+            this.isPathExcluded());
+    };
+    /** Exact match against `tracking.excludeHosts`. */
+    TrackingPolicy.prototype.isHostExcluded = function () {
+        var tracking = this.trackingOptions();
+        if (!tracking)
+            return false;
+        if (typeof window === "undefined")
+            return false;
+        var _a = tracking.excludeHosts, excludeHosts = _a === void 0 ? [] : _a;
+        return excludeHosts.includes(window.location.hostname);
+    };
+    /** Exact match against `tracking.excludePaths`. */
+    TrackingPolicy.prototype.isPathExcluded = function () {
+        var tracking = this.trackingOptions();
+        if (!tracking)
+            return false;
+        if (typeof window === "undefined")
+            return false;
+        var _a = tracking.excludePaths, excludePaths = _a === void 0 ? [] : _a;
+        return excludePaths.includes(window.location.pathname);
+    };
+    /**
+     * Case-insensitive match of the browser-resolved timezone against
+     * `tracking.excludeTimezones`. Client-side and best-effort; see the option's
+     * own documentation.
+     */
+    TrackingPolicy.prototype.isTimezoneExcluded = function () {
+        var tracking = this.trackingOptions();
+        if (!tracking)
+            return false;
+        var _a = tracking.excludeTimezones, excludeTimezones = _a === void 0 ? [] : _a;
+        if (excludeTimezones.length === 0)
+            return false;
+        var timezone = getTimezone();
+        if (!timezone)
+            return false;
+        var lowerTimezone = timezone.toLowerCase();
+        return excludeTimezones.some(function (tz) { return typeof tz === "string" && tz.toLowerCase() === lowerTimezone; });
+    };
+    /**
+     * Whether the CURRENT PAGE is excluded, as opposed to the visitor.
+     *
+     * Host and path exclusions are transient: identity written on an allowed
+     * page must survive a visit to an excluded route, so callers that persist
+     * or restore identity skip the work here rather than purging.
+     */
+    TrackingPolicy.prototype.isPageExcluded = function () {
+        return this.isHostExcluded() || this.isPathExcluded();
+    };
+    /**
+     * Whether a persisted identity cookie should be actively purged, not merely
+     * left unwritten.
+     *
+     * Host and path exclusions are deliberately absent: they are transient
+     * current-page states, so a cookie legitimately written on an allowed page
+     * must survive a visit to an excluded route.
+     */
+    TrackingPolicy.prototype.isPersistedIdentityPurgeRequired = function () {
+        return this.deps.hasOptedOut() || this.isTimezoneExcluded();
+    };
+    /**
+     * Whether the chain in play is in `tracking.excludeChains`.
+     *
+     * Separate from `shouldTrack()` so `identify()` can ask *before* mutating
+     * identity state. `trackEvent()` drops an excluded event silently, but
+     * `identify()` marks the wallet as identified first, so without this an
+     * identify on an excluded chain is dedup-marked and then discarded, and the
+     * wallet never re-emits for the rest of the session even after switching to
+     * an allowed chain. On the Privy path that loses a whole cluster at once.
+     */
+    TrackingPolicy.prototype.isChainExcluded = function (context) {
+        var tracking = this.trackingOptions();
+        if (!tracking)
+            return false;
+        var _a = tracking.excludeChains, excludeChains = _a === void 0 ? [] : _a;
+        if (excludeChains.length === 0)
+            return false;
+        return this.isChainRefused(excludeChains, context);
+    };
+    /**
+     * The shared chain rule, so `shouldTrack()` and `isChainExcluded()` cannot
+     * drift apart. Callers have already established that `excludeChains` is
+     * non-empty.
+     *
+     * Fails CLOSED on an unknown chain. `resolveChainIdForProvider` reports 0
+     * when it has never heard a chain from the signing wallet, and 0 is in no
+     * exclusion list, so treating it as "not excluded" would let through exactly
+     * the events an operator excluded: the wallet on the excluded chain is often
+     * the one we know least about. An explicit exclusion is a directive, so an
+     * unresolvable chain is refused.
+     *
+     * Keyed on 0 and deliberately NOT on `undefined`. 0 is the explicit "we
+     * asked and could not tell" marker. `undefined` means no chain state yet,
+     * which is a legitimate transient (the Privy path reconciles a Solana wallet
+     * through exactly that state), and refusing it would drop real events.
+     * `backfillActiveWallet()` never persists 0, so an unresolvable chain cannot
+     * leak into the central value and reach the unscoped events (page / track /
+     * identify) that fall back to it.
+     */
+    TrackingPolicy.prototype.isChainRefused = function (excludeChains, context) {
+        var _a;
+        var chainToCheck = (_a = context === null || context === void 0 ? void 0 : context.chainId) !== null && _a !== void 0 ? _a : this.deps.currentChainId();
+        if (chainToCheck === 0)
+            return true;
+        if (chainToCheck === undefined)
+            return false;
+        return excludeChains.includes(chainToCheck);
+    };
+    /** Whether an event may be tracked at all, given consent and configuration. */
+    TrackingPolicy.prototype.shouldTrack = function (context) {
+        if (this.deps.hasOptedOut())
+            return false;
+        // An explicit boolean is the whole answer; no exclusions apply to it.
+        var tracking = this.deps.options().tracking;
+        if (typeof tracking === "boolean")
+            return tracking;
+        var configured = this.trackingOptions();
+        if (configured) {
+            if (this.isEnvironmentExcluded())
+                return false;
+            var _a = configured.excludeChains, excludeChains = _a === void 0 ? [] : _a;
+            if (excludeChains.length > 0 && this.isChainRefused(excludeChains, context)) {
+                return false;
+            }
+            return true;
+        }
+        // Nothing configured: track everywhere except localhost.
+        return !isLocalhost();
+    };
+    /** Whether a wallet event kind is enabled for autocapture. Defaults to on. */
+    TrackingPolicy.prototype.isAutocaptureEnabled = function (eventType) {
+        var autocapture = this.deps.options().autocapture;
+        if (autocapture === undefined)
+            return true;
+        if (typeof autocapture === "boolean")
+            return autocapture;
+        if (autocapture !== null && typeof autocapture === "object") {
+            // Only an explicit false disables a kind.
+            return autocapture[eventType] !== false;
+        }
+        return true;
+    };
+    return TrackingPolicy;
+}());
+export { TrackingPolicy };
+//# sourceMappingURL=TrackingPolicy.js.map

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

@@ -1,2 +1,2 @@
-export declare const version = "1.35.2";
+export declare const version = "1.37.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/esm/src/version.js

@@ -1,4 +1,4 @@
 // This file is auto-generated by scripts/update-version.js during npm version
 // Do not edit manually - it will be overwritten
-export var version = '1.35.2';
+export var version = '1.37.0';
 //# sourceMappingURL=version.js.map

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

@@ -96,6 +96,8 @@ export declare class WagmiEventHandler {
      * broadcast to match the receipt against.
      */
     private get pendingTransactions();
+    /** Broadcast batches awaiting `callsStatus`, shared like the map above. */
+    private get pendingBatches();
     constructor(formoAnalytics: FormoAnalytics, wagmiConfig: WagmiConfig, queryClient?: QueryClient);
     /**
      * Set up listeners for wallet connection, disconnection, and chain changes
@@ -228,6 +230,30 @@ export declare class WagmiEventHandler {
      * Handle query cache events (transaction confirmations)
      */
     private handleQueryEvent;
+    /**
+     * Settle a just-registered batch from a status query that already ran.
+     *
+     * Best-effort by design: the minimal QueryClient interface the SDK
+     * accepts is not guaranteed to expose cache lookup, and a missing
+     * `getAll` just means settlement waits for the next query event, which
+     * is where it normally comes from anyway.
+     */
+    private settleFromCachedCallsStatus;
+    /**
+     * Settle an EIP-5792 batch from a `callsStatus` query.
+     *
+     * Only batches whose broadcast this SDK observed are settled: the batch id
+     * must be in `pendingBatches`, for the same reason receipt queries are
+     * gated on an observed hash - queries are visible to any code sharing the
+     * QueryClient, and emitting for an id we never saw broadcast would let a
+     * forged query invent transactions.
+     *
+     * Outcome semantics are shared with the EIP-1193 path (`src/evm/batch.ts`):
+     * per-call receipts outrank the batch verdict, an atomic batch's single
+     * receipt reaches every call, and a 600 leaves receipt-less calls
+     * unsettled rather than guessed.
+     */
+    private handleCallsStatusQuery;
     /**
      * Handle waitForTransactionReceipt query completion
      * Emits CONFIRMED or REVERTED transaction status
@@ -245,6 +271,23 @@ export declare class WagmiEventHandler {
      * Handle transaction mutations (sendTransaction, writeContract)
      */
     private handleTransactionMutation;
+    /**
+     * One `transaction` event per call in an EIP-5792 batch, wagmi path.
+     *
+     * Mirrors `EvmRequestTracker.trackBatchedCalls` exactly: the CALL is the
+     * unit of attribution, so each call gets its own STARTED at pending and
+     * BROADCASTED (with `batch_id`) when the wallet returns an id. The batch's
+     * on-chain outcome arrives through the `callsStatus` query, handled in
+     * `handleCallsStatusQuery`.
+     *
+     * Rejection matches the 1193 path's rule: only a user rejection (4001
+     * anywhere in the error chain) marks the calls rejected - one dismissal
+     * dismisses the whole prompt, so every call in it is rejected, and
+     * reporting only the first would undercount. Any other error (a wallet
+     * without EIP-5792 support, a transport failure) emits nothing further:
+     * inventing a rejection the user never made would be worse.
+     */
+    private handleSendCallsMutation;
     /**
      * Get the current Wagmi state
      * Supports both getState() method and direct state property access

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

@@ -54,6 +54,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import { SignatureStatus, TransactionStatus } from "../types/events";
 import { logger } from "../logger";
+import { readBatchId, readBatchStatusCode, readBatchChainId, batchCallOutcome, batchReceiptForCall, } from "../evm/batch";
 import { encodeWriteContractData, concatCalldataWithSuffix, extractFunctionArgs, buildSafeFunctionArgs, } from "./utils";
 /**
  * Built-in transaction fields that could collide with function args.
@@ -196,6 +197,25 @@ var ownerKey = function (writeKey, config) {
     }
     return "".concat(writeKey, ":").concat(id);
 };
+/**
+ * Was this mutation error the user dismissing the wallet prompt?
+ *
+ * Matches the EIP-1193 path's rule (code 4001), but a wagmi mutation error
+ * arrives wrapped: viem nests the RPC error under `cause`, sometimes twice.
+ * Walk the chain rather than trusting the top level, and accept viem's
+ * `UserRejectedRequestError` by name for wallets that map the rejection to a
+ * typed error without preserving the numeric code.
+ */
+function isUserRejection(error) {
+    var cursor = error;
+    for (var depth = 0; cursor && depth < 5; depth++) {
+        if (cursor.code === 4001 || cursor.name === "UserRejectedRequestError") {
+            return true;
+        }
+        cursor = cursor.cause;
+    }
+    return false;
+}
 /**
  * Pending transactions, shared per destination rather than per handler.
  *
@@ -205,6 +225,7 @@ var ownerKey = function (writeKey, config) {
  * broadcast to match the receipt against.
  */
 var pendingTransactionsByDestination = new Map();
+var pendingBatchesByDestination = new Map();
 /**
  * Pending records outlive a rebuild by the same grace period as the markers.
  * The ordinary rebuild is cleanup THEN remount, so dropping them the instant
@@ -219,6 +240,7 @@ function schedulePendingTransactionExpiry(key) {
     var timer = setTimeout(function () {
         pendingTransactionExpiry.delete(key);
         pendingTransactionsByDestination.delete(key);
+        pendingBatchesByDestination.delete(key);
     }, MARKER_GRACE_MS);
     (_b = (_a = timer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
     pendingTransactionExpiry.set(key, timer);
@@ -285,6 +307,7 @@ export function __resetSeededWallet() {
     pendingTransactionExpiry.forEach(function (t) { return clearTimeout(t); });
     pendingTransactionExpiry.clear();
     pendingTransactionsByDestination.clear();
+    pendingBatchesByDestination.clear();
     announcedConnections.clear();
     liveHandlers.clear();
     markerExpiry.forEach(function (timer) { return clearTimeout(timer); });
@@ -497,6 +520,21 @@ var WagmiEventHandler = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(WagmiEventHandler.prototype, "pendingBatches", {
+        /** Broadcast batches awaiting `callsStatus`, shared like the map above. */
+        get: function () {
+            var _a;
+            var key = (_a = this.ownerKey) !== null && _a !== void 0 ? _a : "";
+            var map = pendingBatchesByDestination.get(key);
+            if (!map) {
+                map = new Map();
+                pendingBatchesByDestination.set(key, map);
+            }
+            return map;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Set up listeners for wallet connection, disconnection, and chain changes
      */
@@ -1449,8 +1487,23 @@ var WagmiEventHandler = /** @class */ (function () {
             return;
         }
         var queryType = queryKey[0];
-        // Only handle waitForTransactionReceipt queries
-        if (queryType !== "waitForTransactionReceipt") {
+        // Only the two query families that settle something we broadcast:
+        // waitForTransactionReceipt for single transactions, callsStatus for
+        // EIP-5792 batches (both useCallsStatus and useWaitForCallsStatus share
+        // the 'callsStatus' key, in wagmi 2 and 3 alike).
+        if (queryType !== "waitForTransactionReceipt" && queryType !== "callsStatus") {
+            return;
+        }
+        // Batch settlement dedupes on the pending-batch registry, NOT on
+        // processedQueries: settling deletes the registration, so a duplicate
+        // delivery finds nothing to do. A processed-key here would be worse
+        // than redundant - the status query can complete BEFORE the sendCalls
+        // mutation registers the batch (TanStack dispatches a mutation's
+        // success state after its onSuccess callbacks, and apps await the
+        // status inside onSuccess), and a key recorded on that early skip
+        // would block every refetch from ever settling the batch.
+        if (queryType === "callsStatus") {
+            this.handleCallsStatusQuery(query);
             return;
         }
         var state = query.state;
@@ -1483,6 +1536,111 @@ var WagmiEventHandler = /** @class */ (function () {
         // Clean up old processed queries to prevent memory leaks
         cleanupOldEntries(this.processedQueries);
     };
+    /**
+     * Settle a just-registered batch from a status query that already ran.
+     *
+     * Best-effort by design: the minimal QueryClient interface the SDK
+     * accepts is not guaranteed to expose cache lookup, and a missing
+     * `getAll` just means settlement waits for the next query event, which
+     * is where it normally comes from anyway.
+     */
+    WagmiEventHandler.prototype.settleFromCachedCallsStatus = function (batchId) {
+        var _a, _b, _c;
+        try {
+            var cache = (_a = this.queryClient) === null || _a === void 0 ? void 0 : _a.getQueryCache();
+            var queries = (_b = cache === null || cache === void 0 ? void 0 : cache.getAll) === null || _b === void 0 ? void 0 : _b.call(cache);
+            if (!Array.isArray(queries))
+                return;
+            for (var _i = 0, queries_1 = queries; _i < queries_1.length; _i++) {
+                var query = queries_1[_i];
+                var key = query === null || query === void 0 ? void 0 : query.queryKey;
+                if (Array.isArray(key) &&
+                    key[0] === "callsStatus" &&
+                    ((_c = key[1]) === null || _c === void 0 ? void 0 : _c.id) === batchId) {
+                    this.handleCallsStatusQuery(query);
+                }
+            }
+        }
+        catch (error) {
+            logger.debug("WagmiEventHandler: cached callsStatus scan failed", error);
+        }
+    };
+    /**
+     * Settle an EIP-5792 batch from a `callsStatus` query.
+     *
+     * Only batches whose broadcast this SDK observed are settled: the batch id
+     * must be in `pendingBatches`, for the same reason receipt queries are
+     * gated on an observed hash - queries are visible to any code sharing the
+     * QueryClient, and emitting for an id we never saw broadcast would let a
+     * forged query invent transactions.
+     *
+     * Outcome semantics are shared with the EIP-1193 path (`src/evm/batch.ts`):
+     * per-call receipts outrank the batch verdict, an atomic batch's single
+     * receipt reaches every call, and a 600 leaves receipt-less calls
+     * unsettled rather than guessed.
+     */
+    WagmiEventHandler.prototype.handleCallsStatusQuery = function (query) {
+        var _this = this;
+        var _a;
+        if (!this.formo.isAutocaptureEnabled("transaction")) {
+            return;
+        }
+        var queryKey = query.queryKey;
+        // Query key format: ['callsStatus', { id, ... }]
+        var params = queryKey[1];
+        var batchId = params === null || params === void 0 ? void 0 : params.id;
+        if (!batchId) {
+            return;
+        }
+        var pending = this.pendingBatches.get(batchId);
+        if (!pending) {
+            logger.debug("WagmiEventHandler: unobserved batch", { batchId: batchId });
+            return;
+        }
+        var state = query.state;
+        if (state.status !== "success" || !state.data) {
+            return;
+        }
+        try {
+            var res_1 = state.data;
+            var code_1 = readBatchStatusCode(res_1);
+            // Below 200 the batch is still pending; the query will update again.
+            if (code_1 === undefined || code_1 < 200) {
+                return;
+            }
+            logger.debug("WagmiEventHandler: batch settled", { batchId: batchId, code: code_1 });
+            // An explicit mutation chain is authoritative. Otherwise prefer the
+            // chain the settlement result names - EIP-5792 v2 reports where the
+            // batch actually landed - over one inferred from the connection at
+            // broadcast, which goes stale if the wallet moves chains while the
+            // prompt is up. Same precedence as the single-transaction receipt
+            // path.
+            var settledChainId_1 = pending.chainIdWasExplicit
+                ? pending.chainId
+                : (_a = readBatchChainId(res_1)) !== null && _a !== void 0 ? _a : pending.chainId;
+            pending.calls.forEach(function (call, index) {
+                var receipt = batchReceiptForCall(res_1, index, pending.calls.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;
+                _this.formo.transaction(__assign(__assign(__assign(__assign({ status: outcome, chainId: settledChainId_1 || 0, address: pending.address }, (call.data && { data: call.data })), (call.to && { to: call.to })), (call.value && { value: call.value })), ((receipt === null || receipt === void 0 ? void 0 : receipt.transactionHash)
+                    ? { transactionHash: receipt.transactionHash }
+                    : {})), {
+                    batch_size: pending.calls.length,
+                    batch_index: index,
+                    batch_id: batchId,
+                });
+            });
+            // Settled; a later refetch of the same query must not re-emit.
+            this.pendingBatches.delete(batchId);
+        }
+        catch (error) {
+            logger.error("WagmiEventHandler: callsStatus error:", error);
+        }
+    };
     /**
      * Handle waitForTransactionReceipt query completion
      * Emits CONFIRMED or REVERTED transaction status
@@ -1612,6 +1770,13 @@ var WagmiEventHandler = /** @class */ (function () {
         if (mutationType === "sendTransaction" || mutationType === "writeContract") {
             this.handleTransactionMutation(mutationType, mutation);
         }
+        // Handle EIP-5792 batch mutations (useSendCalls). Absent this branch,
+        // wagmi-mode apps captured nothing for a batch: the EIP-1193 request
+        // wrapper that handles `wallet_sendCalls` is never installed in wagmi
+        // mode, so the mutation was the only place the batch was visible at all.
+        if (mutationType === "sendCalls") {
+            this.handleSendCallsMutation(mutation);
+        }
         // Clean up old processed mutations to prevent memory leaks
         cleanupOldEntries(this.processedMutations);
     };
@@ -1801,6 +1966,92 @@ var WagmiEventHandler = /** @class */ (function () {
             logger.error("WagmiEventHandler: Error handling transaction mutation:", error);
         }
     };
+    /**
+     * One `transaction` event per call in an EIP-5792 batch, wagmi path.
+     *
+     * Mirrors `EvmRequestTracker.trackBatchedCalls` exactly: the CALL is the
+     * unit of attribution, so each call gets its own STARTED at pending and
+     * BROADCASTED (with `batch_id`) when the wallet returns an id. The batch's
+     * on-chain outcome arrives through the `callsStatus` query, handled in
+     * `handleCallsStatusQuery`.
+     *
+     * Rejection matches the 1193 path's rule: only a user rejection (4001
+     * anywhere in the error chain) marks the calls rejected - one dismissal
+     * dismisses the whole prompt, so every call in it is rejected, and
+     * reporting only the first would undercount. Any other error (a wallet
+     * without EIP-5792 support, a transport failure) emits nothing further:
+     * inventing a rejection the user never made would be worse.
+     */
+    WagmiEventHandler.prototype.handleSendCallsMutation = function (mutation) {
+        var _this = this;
+        if (!this.formo.isAutocaptureEnabled("transaction")) {
+            return;
+        }
+        var state = mutation.state;
+        var variables = state.variables || {};
+        var rawCalls = Array.isArray(variables.calls) ? variables.calls : [];
+        if (rawCalls.length === 0) {
+            return;
+        }
+        // Same resolution order as single transactions: an explicit per-call
+        // value beats the tracked connection.
+        var explicitChainId = normalizeChainId(variables.chainId);
+        var chainId = explicitChainId !== null && explicitChainId !== void 0 ? explicitChainId : this.trackingState.lastChainId;
+        var accountAddress = resolveAccountAddress(variables.account);
+        var userAddress = accountAddress || this.trackingState.lastAddress;
+        if (!userAddress) {
+            logger.warn("WagmiEventHandler: sendCalls without address");
+            return;
+        }
+        try {
+            var calls_1 = rawCalls.map(function (call) { return ({
+                to: call === null || call === void 0 ? void 0 : call.to,
+                value: (call === null || call === void 0 ? void 0 : call.value) !== undefined ? String(call.value) : undefined,
+                data: call === null || call === void 0 ? void 0 : call.data,
+            }); });
+            var emitAll = function (status, extra) {
+                calls_1.forEach(function (call, index) {
+                    _this.formo.transaction(__assign(__assign(__assign({ status: status, chainId: chainId || 0, address: userAddress }, (call.data && { data: call.data })), (call.to && { to: call.to })), (call.value && { value: call.value })), __assign({ batch_size: calls_1.length, batch_index: index }, extra));
+                });
+            };
+            if (state.status === "pending") {
+                // STARTED carries no batch id, exactly as a single transaction has
+                // no hash yet: the wallet has not issued one.
+                logger.debug("WagmiEventHandler: sendCalls start", { calls: calls_1.length });
+                emitAll(TransactionStatus.STARTED);
+            }
+            else if (state.status === "success") {
+                var batchId = readBatchId(state.data);
+                logger.debug("WagmiEventHandler: sendCalls broadcast", { batchId: batchId });
+                emitAll(TransactionStatus.BROADCASTED, batchId ? { batch_id: batchId } : undefined);
+                if (batchId) {
+                    this.pendingBatches.set(batchId, __assign(__assign({ address: userAddress }, (chainId !== undefined && { chainId: chainId })), { chainIdWasExplicit: explicitChainId !== undefined, calls: calls_1 }));
+                    // Same bound as pendingTransactions, same reason.
+                    if (this.pendingBatches.size > 100) {
+                        var keys = Array.from(this.pendingBatches.keys());
+                        for (var i = 0; i < 50 && i < keys.length; i++) {
+                            this.pendingBatches.delete(keys[i]);
+                        }
+                    }
+                    // The status query can have completed BEFORE this registration:
+                    // TanStack dispatches a mutation's success state after its
+                    // onSuccess callbacks, and apps await waitForCallsStatus inside
+                    // onSuccess. That early query event found no registration and did
+                    // nothing, so look for its settled result in the cache now.
+                    this.settleFromCachedCallsStatus(batchId);
+                }
+            }
+            else if (state.status === "error") {
+                if (isUserRejection(state.error)) {
+                    logger.debug("WagmiEventHandler: sendCalls rejected");
+                    emitAll(TransactionStatus.REJECTED);
+                }
+            }
+        }
+        catch (error) {
+            logger.error("WagmiEventHandler: sendCalls error:", error);
+        }
+    };
     /**
      * Get the current Wagmi state
      * Supports both getState() method and direct state property access