@formo/analytics 1.26.0 → 1.27.0

package/dist/esm/src/event/EventFactory.d.ts

@@ -27,7 +27,7 @@ declare class EventFactory implements IEventFactory {
     generateDisconnectEvent(chainId?: ChainID, address?: Address, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
     generateChainChangedEvent(chainId: ChainID, address: Address, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
     generateSignatureEvent(status: SignatureStatus, chainId: ChainID, address: Address, message: string, signatureHash?: string, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
-    generateTransactionEvent(status: TransactionStatus, chainId: ChainID, address: Address, data: string, to: string, value: string, transactionHash?: string, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
+    generateTransactionEvent(status: TransactionStatus, chainId: ChainID, address: Address, data?: string, to?: string, value?: string, transactionHash?: string, function_name?: string, function_args?: Record<string, unknown>, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
     generateTrackEvent(event: string, properties?: IFormoEventProperties, context?: IFormoEventContext): Promise<IFormoEvent>;
     create(event: APIEvent, address?: Address, userId?: string): Promise<IFormoEvent>;
 }

package/dist/esm/src/event/EventFactory.js

@@ -403,12 +403,12 @@ var EventFactory = /** @class */ (function () {
             });
         });
     };
-    EventFactory.prototype.generateTransactionEvent = function (status, chainId, address, data, to, value, transactionHash, properties, context) {
+    EventFactory.prototype.generateTransactionEvent = function (status, chainId, address, data, to, value, transactionHash, function_name, function_args, properties, context) {
         return __awaiter(this, void 0, void 0, function () {
             var transactionEvent;
             return __generator(this, function (_a) {
                 transactionEvent = {
-                    properties: __assign(__assign({ status: status, chainId: chainId, data: data, to: to, value: value }, (transactionHash && { transactionHash: transactionHash })), properties),
+                    properties: __assign(__assign(__assign(__assign(__assign(__assign(__assign({ status: status, chainId: chainId }, (data && { data: data })), (to && { to: to })), (value && { value: value })), (transactionHash && { transactionHash: transactionHash })), (function_name && { function_name: function_name })), (function_args && { function_args: function_args })), properties),
                     address: address,
                     type: "transaction",
                 };
@@ -487,7 +487,7 @@ var EventFactory = /** @class */ (function () {
                     case 14:
                         formoEvent = _b.sent();
                         return [3 /*break*/, 19];
-                    case 15: return [4 /*yield*/, this.generateTransactionEvent(event.status, event.chainId, event.address, event.data, event.to, event.value, event.transactionHash, event.properties, event.context)];
+                    case 15: return [4 /*yield*/, this.generateTransactionEvent(event.status, event.chainId, event.address, event.data, event.to, event.value, event.transactionHash, event.function_name, event.function_args, event.properties, event.context)];
                     case 16:
                         formoEvent = _b.sent();
                         return [3 /*break*/, 19];

package/dist/esm/src/fetch/index.d.ts

@@ -1,3 +1,11 @@
-declare const _default: (input: string | URL | Request, init?: (RequestInit & import("fetch-retry").RequestInitRetryParams<typeof globalThis.fetch>) | undefined) => Promise<Response>;
-export default _default;
+export interface FetchRetryError extends Error {
+    response?: Response;
+}
+type RetryOptions = {
+    retries?: number;
+    retryDelay?: (attempt: number) => number;
+    retryOn?: (attempt: number, error: FetchRetryError | null, response: Response | null) => boolean;
+};
+declare function fetchWithRetry(input: RequestInfo | URL, init?: RequestInit & RetryOptions): Promise<Response>;
+export default fetchWithRetry;
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/src/fetch/index.js

@@ -1,3 +1,124 @@
-import fetch from "fetch-retry";
-export default fetch(global.fetch);
+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;
+};
+function fetchWithRetry(input, init) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, _b, retries, retryDelay, retryOn, fetchInit, _loop_1, attempt, state_1;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _a = init || {}, _b = _a.retries, retries = _b === void 0 ? 0 : _b, retryDelay = _a.retryDelay, retryOn = _a.retryOn, fetchInit = __rest(_a, ["retries", "retryDelay", "retryOn"]);
+                    _loop_1 = function (attempt) {
+                        var isLastAttempt, response, responseError, error_1;
+                        return __generator(this, function (_d) {
+                            switch (_d.label) {
+                                case 0:
+                                    isLastAttempt = attempt === retries;
+                                    _d.label = 1;
+                                case 1:
+                                    _d.trys.push([1, 6, , 10]);
+                                    return [4 /*yield*/, globalThis.fetch(input, fetchInit)];
+                                case 2:
+                                    response = _d.sent();
+                                    if (response.ok) {
+                                        return [2 /*return*/, { value: response }];
+                                    }
+                                    // On the last attempt, return whatever we got
+                                    if (isLastAttempt) {
+                                        return [2 /*return*/, { value: response }];
+                                    }
+                                    responseError = new Error(response.statusText);
+                                    responseError.response = response;
+                                    if (!(retryOn === null || retryOn === void 0 ? void 0 : retryOn(attempt, responseError, response))) return [3 /*break*/, 5];
+                                    if (!retryDelay) return [3 /*break*/, 4];
+                                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, retryDelay(attempt)); })];
+                                case 3:
+                                    _d.sent();
+                                    _d.label = 4;
+                                case 4: return [2 /*return*/, "continue"];
+                                case 5: return [2 /*return*/, { value: response }];
+                                case 6:
+                                    error_1 = _d.sent();
+                                    // On the last attempt, throw immediately
+                                    if (isLastAttempt) {
+                                        throw error_1;
+                                    }
+                                    if (!(retryOn === null || retryOn === void 0 ? void 0 : retryOn(attempt, error_1, null))) return [3 /*break*/, 9];
+                                    if (!retryDelay) return [3 /*break*/, 8];
+                                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, retryDelay(attempt)); })];
+                                case 7:
+                                    _d.sent();
+                                    _d.label = 8;
+                                case 8: return [2 /*return*/, "continue"];
+                                case 9: throw error_1;
+                                case 10: return [2 /*return*/];
+                            }
+                        });
+                    };
+                    attempt = 0;
+                    _c.label = 1;
+                case 1:
+                    if (!(attempt <= retries)) return [3 /*break*/, 4];
+                    return [5 /*yield**/, _loop_1(attempt)];
+                case 2:
+                    state_1 = _c.sent();
+                    if (typeof state_1 === "object")
+                        return [2 /*return*/, state_1.value];
+                    _c.label = 3;
+                case 3:
+                    attempt++;
+                    return [3 /*break*/, 1];
+                case 4: 
+                // Unreachable — the loop always returns or throws on the last attempt.
+                // Required to satisfy TypeScript's control flow analysis.
+                throw new Error("Unexpected: retry loop exited without returning or throwing");
+            }
+        });
+    });
+}
+export default fetchWithRetry;
 //# sourceMappingURL=index.js.map

package/dist/esm/src/queue/EventQueue.d.ts

@@ -1,5 +1,8 @@
-import { IFormoEvent } from "../types";
+import { IFormoEvent, IFormoEventPayload } from "../types";
 import { IEventQueue } from "./type";
+type IFormoEventFlushPayload = IFormoEventPayload & {
+    sent_at: string;
+};
 type Options = {
     apiHost: string;
     flushAt?: number;
@@ -25,7 +28,26 @@ export declare class EventQueue implements IEventQueue {
     constructor(writeKey: string, options: Options);
     private generateMessageId;
     enqueue(event: IFormoEvent, callback?: (...args: any) => void): Promise<void>;
-    flush(callback?: (...args: any) => void): Promise<any>;
+    flush(callback?: (...args: any) => void): Promise<void | IFormoEventFlushPayload[]>;
+    /**
+     * Returns the UTF-8 byte length of a string. The browser's keepalive limit
+     * is enforced on the wire (UTF-8 bytes), not on JS string length (UTF-16
+     * code units). Non-ASCII characters (CJK, emoji) can be 2–4x larger in
+     * UTF-8 than their string .length suggests.
+     */
+    private static byteLength;
+    /**
+     * Splits events into batches that respect the browser's 64KB keepalive
+     * payload size limit. Each batch pairs its serialized data with the
+     * original queue items (for per-item callback reporting) and a flag
+     * indicating whether keepalive is safe to use.
+     */
+    private splitIntoBatches;
+    /**
+     * Sends batches sequentially, notifying per-item callbacks on success/failure.
+     * Returns the first error encountered (if any) so the caller can report it.
+     */
+    private sendBatches;
     private isErrorRetryable;
     private isDuplicate;
     private onPageLeave;

package/dist/esm/src/queue/EventQueue.js

@@ -51,6 +51,16 @@ import { logger } from "../logger";
 import { EVENTS_API_REQUEST_HEADER } from "../constants";
 import fetch from "../fetch";
 var noop = function () { };
+var safeCall = function (fn) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    try {
+        fn.apply(void 0, args);
+    }
+    catch ( /* swallow */_a) { /* swallow */ }
+};
 var DEFAULT_RETRY = 3;
 var MAX_RETRY = 5;
 var MIN_RETRY = 1;
@@ -60,6 +70,10 @@ var MIN_FLUSH_AT = 1;
 var DEFAULT_QUEUE_SIZE = 1024 * 500; // 500kB
 var MAX_QUEUE_SIZE = 1024 * 500; // 500kB
 var MIN_QUEUE_SIZE = 200; // 200 bytes
+// Browsers enforce a 64KB limit on the total body size of in-flight
+// keepalive fetch requests. Payloads exceeding this are silently cancelled,
+// producing a TypeError: Failed to fetch that cannot be resolved by retrying.
+var KEEPALIVE_PAYLOAD_LIMIT = 64 * 1024; // 64kB
 var DEFAULT_FLUSH_INTERVAL = 1000 * 30; // 1 MINUTE
 var MAX_FLUSH_INTERVAL = 1000 * 300; // 5 MINUTES
 var MIN_FLUSH_INTERVAL = 1000 * 10; // 10 SECONDS
@@ -144,7 +158,6 @@ var EventQueue = /** @class */ (function () {
             });
         }); });
     }
-    //#region Public functions
     EventQueue.prototype.generateMessageId = function (event) {
         return __awaiter(this, void 0, void 0, function () {
             var formattedTimestamp, eventForHashing, eventString;
@@ -200,7 +213,7 @@ var EventQueue = /** @class */ (function () {
     };
     EventQueue.prototype.flush = function (callback) {
         return __awaiter(this, void 0, void 0, function () {
-            var err_1, items, sentAt, data, done;
+            var items, sentAt, data, batches;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -214,75 +227,171 @@ var EventQueue = /** @class */ (function () {
                             callback();
                             return [2 /*return*/, Promise.resolve()];
                         }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 4, , 5]);
-                        if (!this.pendingFlush) return [3 /*break*/, 3];
+                        if (!this.pendingFlush) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.pendingFlush];
-                    case 2:
+                    case 1:
                         _a.sent();
-                        _a.label = 3;
-                    case 3: return [3 /*break*/, 5];
-                    case 4:
-                        err_1 = _a.sent();
-                        this.pendingFlush = null;
-                        throw err_1;
-                    case 5:
+                        _a.label = 2;
+                    case 2:
                         items = this.queue.splice(0, this.flushAt);
                         this.payloadHashes.clear();
                         sentAt = new Date().toISOString();
                         data = items.map(function (item) { return (__assign(__assign({}, item.message), { sent_at: sentAt })); });
-                        done = function (err) {
-                            items.forEach(function (_a) {
-                                var message = _a.message, callback = _a.callback;
-                                return callback(err, message, data);
-                            });
-                            callback(err, data);
-                        };
-                        return [2 /*return*/, (this.pendingFlush = fetch("".concat(this.apiHost), {
-                                headers: EVENTS_API_REQUEST_HEADER(this.writeKey),
-                                method: "POST",
-                                body: JSON.stringify(data),
-                                keepalive: true,
-                                retries: this.retryCount,
-                                retryDelay: function (attempt) { return Math.pow(2, attempt) * 1000; }, // exponential backoff
-                                retryOn: function (_, error) { return _this.isErrorRetryable(error); },
-                            })
-                                .then(function () {
-                                done();
+                        batches = this.splitIntoBatches(items, data);
+                        return [2 /*return*/, (this.pendingFlush = this.sendBatches(batches, data)
+                                .then(function (firstError) {
+                                if (firstError) {
+                                    safeCall(callback, firstError, data);
+                                    if (typeof _this.errorHandler === "function") {
+                                        safeCall(_this.errorHandler, firstError);
+                                    }
+                                }
+                                else {
+                                    safeCall(callback, undefined, data);
+                                }
                                 return Promise.resolve(data);
                             })
                                 .catch(function (err) {
+                                // Defensive: should not be reachable since sendBatches catches
+                                // all errors internally, but guard against unexpected failures.
+                                safeCall(callback, err, data);
                                 if (typeof _this.errorHandler === "function") {
-                                    done(err);
-                                    return _this.errorHandler(err);
-                                }
-                                if (err.response) {
-                                    var error = new Error(err.response.statusText);
-                                    done(error);
-                                    throw error;
+                                    safeCall(_this.errorHandler, err);
                                 }
-                                done(err);
-                                throw err;
+                                // Do NOT re-throw — analytics errors should never
+                                // propagate as unhandled rejections to the host app
                             }))];
                 }
             });
         });
     };
-    //#region Utility functions
-    EventQueue.prototype.isErrorRetryable = function (error) {
-        var _a, _b, _c;
+    /**
+     * Returns the UTF-8 byte length of a string. The browser's keepalive limit
+     * is enforced on the wire (UTF-8 bytes), not on JS string length (UTF-16
+     * code units). Non-ASCII characters (CJK, emoji) can be 2–4x larger in
+     * UTF-8 than their string .length suggests.
+     */
+    EventQueue.byteLength = function (str) {
+        return new TextEncoder().encode(str).byteLength;
+    };
+    /**
+     * Splits events into batches that respect the browser's 64KB keepalive
+     * payload size limit. Each batch pairs its serialized data with the
+     * original queue items (for per-item callback reporting) and a flag
+     * indicating whether keepalive is safe to use.
+     */
+    EventQueue.prototype.splitIntoBatches = function (items, data) {
+        var serialized = JSON.stringify(data);
+        if (EventQueue.byteLength(serialized) <= KEEPALIVE_PAYLOAD_LIMIT) {
+            return [{ data: data, items: items, keepalive: true }];
+        }
+        var batches = [];
+        var currentData = [];
+        var currentItems = [];
+        var currentSize = 2; // account for JSON array brackets "[]"
+        for (var i = 0; i < data.length; i++) {
+            var event_1 = data[i];
+            var eventSize = EventQueue.byteLength(JSON.stringify(event_1));
+            var sizeWithEvent = currentSize + (currentData.length > 0 ? 1 : 0) + eventSize;
+            if (sizeWithEvent > KEEPALIVE_PAYLOAD_LIMIT) {
+                if (currentData.length > 0) {
+                    batches.push({ data: currentData, items: currentItems, keepalive: true });
+                }
+                // If a single event exceeds the limit, send it without keepalive
+                if (eventSize + 2 > KEEPALIVE_PAYLOAD_LIMIT) {
+                    batches.push({ data: [event_1], items: [items[i]], keepalive: false });
+                    currentData = [];
+                    currentItems = [];
+                    currentSize = 2;
+                }
+                else {
+                    currentData = [event_1];
+                    currentItems = [items[i]];
+                    currentSize = 2 + eventSize;
+                }
+            }
+            else {
+                currentData.push(event_1);
+                currentItems.push(items[i]);
+                currentSize = sizeWithEvent;
+            }
+        }
+        if (currentData.length > 0) {
+            batches.push({ data: currentData, items: currentItems, keepalive: true });
+        }
+        return batches;
+    };
+    /**
+     * Sends batches sequentially, notifying per-item callbacks on success/failure.
+     * Returns the first error encountered (if any) so the caller can report it.
+     */
+    EventQueue.prototype.sendBatches = function (batches, allData) {
+        return __awaiter(this, void 0, void 0, function () {
+            var firstError, _i, batches_1, batch, body, response, error, err_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _i = 0, batches_1 = batches;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < batches_1.length)) return [3 /*break*/, 6];
+                        batch = batches_1[_i];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        body = JSON.stringify(batch.data);
+                        return [4 /*yield*/, fetch("".concat(this.apiHost), {
+                                headers: EVENTS_API_REQUEST_HEADER(this.writeKey),
+                                method: "POST",
+                                body: body,
+                                keepalive: batch.keepalive,
+                                retries: this.retryCount,
+                                retryDelay: function (attempt) { return Math.pow(2, attempt) * 1000; },
+                                retryOn: function (_, error, response) { return _this.isErrorRetryable(error, response); },
+                            })];
+                    case 3:
+                        response = _a.sent();
+                        if (!response.ok) {
+                            error = new Error(response.statusText || "HTTP ".concat(response.status));
+                            error.response = response;
+                            throw error;
+                        }
+                        batch.items.forEach(function (_a) {
+                            var message = _a.message, cb = _a.callback;
+                            return safeCall(cb, undefined, message, allData);
+                        });
+                        return [3 /*break*/, 5];
+                    case 4:
+                        err_1 = _a.sent();
+                        firstError = firstError || err_1;
+                        batch.items.forEach(function (_a) {
+                            var message = _a.message, cb = _a.callback;
+                            return safeCall(cb, err_1, message, allData);
+                        });
+                        return [3 /*break*/, 5];
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 6: return [2 /*return*/, firstError];
+                }
+            });
+        });
+    };
+    EventQueue.prototype.isErrorRetryable = function (error, response) {
+        var _a, _b;
         // Retry Network Errors.
-        if (isNetworkError(error))
+        if (error && isNetworkError(error))
             return true;
-        // Cannot determine if the request can be retried
-        if (!(error === null || error === void 0 ? void 0 : error.response))
+        // Check response status if available
+        var status = (_a = response === null || response === void 0 ? void 0 : response.status) !== null && _a !== void 0 ? _a : (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.status;
+        if (!status)
             return false;
         // Retry Server Errors (5xx).
-        if (((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status) >= 500 && ((_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.status) <= 599)
+        if (status >= 500 && status <= 599)
             return true;
         // Retry if rate limited.
-        if (((_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.status) === 429)
+        if (status === 429)
             return true;
         return false;
     };

package/dist/esm/src/types/base.d.ts

@@ -41,6 +41,8 @@ export interface IFormoAnalytics {
         to?: string;
         value?: string;
         transactionHash?: string;
+        function_name?: string;
+        function_args?: Record<string, unknown>;
     }, properties?: IFormoEventProperties, context?: IFormoEventContext, callback?: (...args: unknown[]) => void): Promise<void>;
     identify(params: {
         address: Address;
@@ -172,6 +174,12 @@ export interface Options {
      * @example { queryParams: ["via"], pathPattern: "/r/([^/]+)" }
      */
     referral?: ReferralOptions;
+    /**
+     * Optional error handler for analytics network failures.
+     * Called when event flush fails after all retries.
+     * If not provided, errors are silently swallowed.
+     */
+    errorHandler?: (err: Error) => void;
     ready?: (formo: IFormoAnalytics) => void;
 }
 export interface FormoAnalyticsProviderProps {

package/dist/esm/src/types/events.d.ts

@@ -59,10 +59,12 @@ export interface TransactionAPIEvent {
     status: TransactionStatus;
     chainId: ChainID;
     address: Address;
-    data: string;
-    to: string;
-    value: string;
+    data?: string;
+    to?: string;
+    value?: string;
     transactionHash?: string;
+    function_name?: string;
+    function_args?: Record<string, unknown>;
 }
 export interface SignatureAPIEvent {
     type: "signature";

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

@@ -1,2 +1,2 @@
-export declare const version = "1.26.0";
+export declare const version = "1.27.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.26.0';
+export var version = '1.27.0';
 //# sourceMappingURL=version.js.map

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

@@ -18,6 +18,16 @@ export declare class WagmiEventHandler {
      * Key format: `${mutationId}:${status}`
      */
     private processedMutations;
+    /**
+     * Track processed query states to prevent duplicate event emissions
+     * Key format: `${queryHash}:${status}`
+     */
+    private processedQueries;
+    /**
+     * Store transaction details from BROADCASTED events for use in CONFIRMED/REVERTED
+     * Key: transactionHash, Value: transaction details including the original sender address
+     */
+    private pendingTransactions;
     constructor(formoAnalytics: FormoAnalytics, wagmiConfig: WagmiConfig, queryClient?: QueryClient);
     /**
      * Set up listeners for wallet connection, disconnection, and chain changes
@@ -35,6 +45,20 @@ export declare class WagmiEventHandler {
      * Set up mutation tracking for signatures and transactions
      */
     private setupMutationTracking;
+    /**
+     * Set up query tracking for transaction confirmations
+     * Listens for waitForTransactionReceipt queries to detect CONFIRMED status
+     */
+    private setupQueryTracking;
+    /**
+     * Handle query cache events (transaction confirmations)
+     */
+    private handleQueryEvent;
+    /**
+     * Handle waitForTransactionReceipt query completion
+     * Emits CONFIRMED or REVERTED transaction status
+     */
+    private handleTransactionReceiptQuery;
     /**
      * Handle mutation cache events (signatures, transactions)
      */