@formo/analytics 1.36.0 → 1.37.0

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

@@ -0,0 +1,123 @@
+import { TransactionStatus } from "../types/events";
+/**
+ * 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 function readBatchId(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;
+}
+/**
+ * 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 function readBatchStatusCode(res) {
+    if (typeof (res === null || res === void 0 ? void 0 : res.statusCode) === "number")
+        return res.statusCode;
+    if (typeof (res === null || res === void 0 ? void 0 : res.status) === "number")
+        return res.status;
+    return 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 function readBatchChainId(res) {
+    var raw = res === null || res === void 0 ? void 0 : res.chainId;
+    if (typeof raw === "number" && Number.isFinite(raw) && raw > 0)
+        return raw;
+    if (typeof raw === "string") {
+        var parsed = parseInt(raw, 16);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return parsed;
+    }
+    return 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 function batchCallOutcome(code, receipt) {
+    var receiptStatus = receipt === null || receipt === void 0 ? void 0 : receipt.status;
+    if (receiptStatus !== undefined) {
+        return receiptStatus === "0x0" ||
+            receiptStatus === 0 ||
+            receiptStatus === "reverted"
+            ? 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 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 function batchReceiptForCall(res, index, callCount) {
+    var _a;
+    var receipts = Array.isArray(res === null || res === void 0 ? void 0 : res.receipts) ? res.receipts : [];
+    var code = (_a = readBatchStatusCode(res)) !== null && _a !== void 0 ? _a : 0;
+    var atomic = (res === null || res === void 0 ? void 0 : res.atomic) === true ||
+        ((res === null || res === void 0 ? void 0 : res.atomic) === undefined &&
+            receipts.length === 1 &&
+            callCount > 1 &&
+            code < 600);
+    return atomic ? receipts[0] : receipts[index];
+}
+//# sourceMappingURL=batch.js.map

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

@@ -1,2 +1,2 @@
-export declare const version = "1.36.0";
+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.36.0';
+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