@formo/analytics 1.36.0 → 1.37.0

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

@@ -58,6 +58,7 @@ exports.WagmiEventHandler = exports.MARKER_GRACE_MS = void 0;
 exports.__resetSeededWallet = __resetSeededWallet;
 var events_1 = require("../types/events");
 var logger_1 = require("../logger");
+var batch_1 = require("../evm/batch");
 var utils_1 = require("./utils");
 /**
  * Built-in transaction fields that could collide with function args.
@@ -200,6 +201,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.
  *
@@ -209,6 +229,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
@@ -223,6 +244,7 @@ function schedulePendingTransactionExpiry(key) {
     var timer = setTimeout(function () {
         pendingTransactionExpiry.delete(key);
         pendingTransactionsByDestination.delete(key);
+        pendingBatchesByDestination.delete(key);
     }, exports.MARKER_GRACE_MS);
     (_b = (_a = timer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
     pendingTransactionExpiry.set(key, timer);
@@ -289,6 +311,7 @@ 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); });
@@ -501,6 +524,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
      */
@@ -1453,8 +1491,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;
@@ -1487,6 +1540,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_1.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_1.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 = (0, batch_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_1.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 = (0, batch_1.readBatchChainId)(res_1)) !== null && _a !== void 0 ? _a : pending.chainId;
+            pending.calls.forEach(function (call, index) {
+                var receipt = (0, batch_1.batchReceiptForCall)(res_1, index, pending.calls.length);
+                var outcome = (0, batch_1.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_1.logger.error("WagmiEventHandler: callsStatus error:", error);
+        }
+    };
     /**
      * Handle waitForTransactionReceipt query completion
      * Emits CONFIRMED or REVERTED transaction status
@@ -1616,6 +1774,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);
     };
@@ -1805,6 +1970,92 @@ var WagmiEventHandler = /** @class */ (function () {
             logger_1.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_1.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_1.logger.debug("WagmiEventHandler: sendCalls start", { calls: calls_1.length });
+                emitAll(events_1.TransactionStatus.STARTED);
+            }
+            else if (state.status === "success") {
+                var batchId = (0, batch_1.readBatchId)(state.data);
+                logger_1.logger.debug("WagmiEventHandler: sendCalls broadcast", { batchId: batchId });
+                emitAll(events_1.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_1.logger.debug("WagmiEventHandler: sendCalls rejected");
+                    emitAll(events_1.TransactionStatus.REJECTED);
+                }
+            }
+        }
+        catch (error) {
+            logger_1.logger.error("WagmiEventHandler: sendCalls error:", error);
+        }
+    };
     /**
      * Get the current Wagmi state
      * Supports both getState() method and direct state property access

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

@@ -68,42 +68,20 @@ export declare class EvmRequestTracker {
     /**
      * 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
      * per-call receipts say otherwise on a non-atomic batch.
      */
     private trackBatchedCalls;
-    /**
-     * 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.
-     */
-    private batchCallOutcome;
-    /**
-     * 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.
-     */
-    private readBatchId;
     /**
      * Resolve a batch through `wallet_getCallsStatus`.
      *

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

@@ -60,6 +60,7 @@ 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.
  *
@@ -511,11 +512,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
@@ -586,7 +590,7 @@ var EvmRequestTracker = /** @class */ (function () {
                         return [4 /*yield*/, sendPromise];
                     case 2:
                         result = _d.sent();
-                        batchId = this.readBatchId(result);
+                        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"]);
@@ -621,54 +625,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 +647,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 +662,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.

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

@@ -0,0 +1,94 @@
+import { TransactionStatus } from "../types/events";
+/**
+ * EIP-5792 batch settlement, shared by both capture paths.
+ *
+ * The EIP-1193 request wrapper (`EvmRequestTracker`) and the wagmi cache
+ * observer (`WagmiEventHandler`) each see a batch through a different
+ * transport, but a settled batch means the same thing in both. Keeping the
+ * outcome rules in one place is what stops the two paths from drifting into
+ * reporting the same batch differently depending on how the app happened to
+ * integrate the SDK.
+ */
+/** A settled batch as `wallet_getCallsStatus` (or viem's wrapper) reports it. */
+export type BatchStatusResult = {
+    status?: number | string;
+    statusCode?: number;
+    atomic?: boolean;
+    chainId?: number | string;
+    receipts?: BatchReceipt[];
+} | null | undefined;
+export type BatchReceipt = {
+    status?: string | number;
+    transactionHash?: string;
+};
+/**
+ * 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.
+ */
+export declare function readBatchId(result: unknown): string | undefined;
+/**
+ * The numeric EIP-5792 status code from a settlement result.
+ *
+ * A wallet answers `wallet_getCallsStatus` with a numeric `status`; viem's
+ * `getCallsStatus` renames that to `statusCode` and puts a summary string in
+ * `status` instead. Both shapes arrive here depending on the capture path,
+ * so read the number wherever it is and never trust the string.
+ */
+export declare function readBatchStatusCode(res: BatchStatusResult): number | undefined;
+/**
+ * The chain a settled batch reports itself on.
+ *
+ * EIP-5792 v2 puts `chainId` in the `wallet_getCallsStatus` response as hex;
+ * viem returns it as a number. Either way it names the chain the batch
+ * actually settled on, which outranks a chain merely inferred from the
+ * connection at broadcast time - the wallet can move chains while the
+ * prompt is up.
+ */
+export declare function readBatchChainId(res: BatchStatusResult): number | undefined;
+/**
+ * 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.
+ *
+ * Receipt statuses come in two spellings: raw RPC (`"0x0"`/`"0x1"`, or the
+ * numbers) and viem-formatted (`"reverted"`/`"success"`), because the wagmi
+ * path sees receipts after viem has normalised them.
+ *
+ * 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.
+ */
+export declare function batchCallOutcome(code: number, receipt?: BatchReceipt): TransactionStatus | undefined;
+/**
+ * The receipt that decides call `index`, honouring atomic execution.
+ *
+ * An atomic batch lands as ONE on-chain transaction, so the wallet returns a
+ * single receipt covering every call. Indexing receipts positionally there
+ * would hand the shared hash to call 0 and leave its siblings hashless and
+ * decided only by the batch verdict. Every call in an atomic batch shares
+ * the one receipt - same hash, same fate - which is also what makes
+ * `count(distinct transaction_hash)` count on-chain transactions correctly.
+ *
+ * The wallet's own `atomic` flag is authoritative in BOTH directions. An
+ * explicit `atomic: false` with a single receipt is a real shape - a
+ * non-atomic batch whose execution stopped after one call mined - and
+ * sharing that receipt would hand calls that never reached the chain a
+ * transaction hash they do not have. Only when the field is ABSENT (a
+ * wallet predating it, reached over raw EIP-1193; viem fills the field in,
+ * so the wagmi path never lands here) does the conservative inference
+ * apply: one receipt for several calls on a batch that is NOT partially
+ * reverted can only be atomic execution (600 explicitly means some calls
+ * reverted and others did not, which one shared transaction cannot do).
+ */
+export declare function batchReceiptForCall(res: BatchStatusResult, index: number, callCount: number): BatchReceipt | undefined;
+//# sourceMappingURL=batch.d.ts.map