@formo/analytics 1.25.0 → 1.27.0

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

@@ -0,0 +1,666 @@
+/**
+ * WagmiEventHandler
+ *
+ * Handles wallet event tracking by hooking into Wagmi v2's config.subscribe()
+ * and TanStack Query's MutationCache. This replaces the EIP-1193 provider
+ * wrapping approach when Wagmi mode is enabled.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { SignatureStatus, TransactionStatus } from "../types/events";
+import { logger } from "../logger";
+import { encodeWriteContractData, extractFunctionArgs, buildSafeFunctionArgs, } from "./utils";
+/**
+ * Built-in transaction fields that could collide with function args.
+ * Defined at module level to avoid recreating on every method call.
+ */
+var RESERVED_FIELDS = new Set([
+    "status",
+    "chainId",
+    "address",
+    "data",
+    "to",
+    "value",
+    "transactionHash",
+    "function_name",
+    "function_args",
+]);
+/**
+ * Clean up old entries from a Set to prevent memory leaks.
+ * Removes oldest entries when size exceeds maxSize.
+ *
+ * @param set - The Set to clean up
+ * @param maxSize - Maximum allowed size before cleanup (default: 1000)
+ * @param removeCount - Number of entries to remove (default: 500)
+ */
+function cleanupOldEntries(set, maxSize, removeCount) {
+    if (maxSize === void 0) { maxSize = 1000; }
+    if (removeCount === void 0) { removeCount = 500; }
+    if (set.size > maxSize) {
+        var entries = Array.from(set);
+        for (var i = 0; i < removeCount && i < entries.length; i++) {
+            set.delete(entries[i]);
+        }
+    }
+}
+var WagmiEventHandler = /** @class */ (function () {
+    function WagmiEventHandler(formoAnalytics, wagmiConfig, queryClient) {
+        this.unsubscribers = [];
+        this.trackingState = {
+            isProcessing: false,
+        };
+        /**
+         * Track processed mutation states to prevent duplicate event emissions
+         * Key format: `${mutationId}:${status}`
+         */
+        this.processedMutations = new Set();
+        /**
+         * Track processed query states to prevent duplicate event emissions
+         * Key format: `${queryHash}:${status}`
+         */
+        this.processedQueries = new Set();
+        /**
+         * Store transaction details from BROADCASTED events for use in CONFIRMED/REVERTED
+         * Key: transactionHash, Value: transaction details including the original sender address
+         */
+        this.pendingTransactions = new Map();
+        this.formo = formoAnalytics;
+        this.wagmiConfig = wagmiConfig;
+        this.queryClient = queryClient;
+        logger.info("WagmiEventHandler: Initializing Wagmi integration");
+        // Set up connection/disconnection/chain listeners
+        this.setupConnectionListeners();
+        // Set up mutation and query tracking if QueryClient is provided
+        if (this.queryClient) {
+            this.setupMutationTracking();
+            this.setupQueryTracking();
+        }
+        else {
+            logger.warn("WagmiEventHandler: QueryClient not provided, signature and transaction events will not be tracked");
+        }
+    }
+    /**
+     * Set up listeners for wallet connection, disconnection, and chain changes
+     */
+    WagmiEventHandler.prototype.setupConnectionListeners = function () {
+        var _this = this;
+        logger.info("WagmiEventHandler: Setting up connection listeners");
+        // Subscribe to status changes (connect/disconnect)
+        var statusUnsubscribe = this.wagmiConfig.subscribe(function (state) { return state.status; }, function (status, prevStatus) {
+            _this.handleStatusChange(status, prevStatus);
+        });
+        this.unsubscribers.push(statusUnsubscribe);
+        // Subscribe to chain ID changes
+        var chainIdUnsubscribe = this.wagmiConfig.subscribe(function (state) { return state.chainId; }, function (chainId, prevChainId) {
+            _this.handleChainChange(chainId, prevChainId);
+        });
+        this.unsubscribers.push(chainIdUnsubscribe);
+        logger.info("WagmiEventHandler: Connection listeners set up successfully");
+    };
+    /**
+     * Handle status changes (connect/disconnect)
+     */
+    WagmiEventHandler.prototype.handleStatusChange = function (status, prevStatus) {
+        return __awaiter(this, void 0, void 0, function () {
+            var state, address, chainId, connectorName, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Prevent concurrent processing
+                        if (this.trackingState.isProcessing) {
+                            logger.debug("WagmiEventHandler: Already processing status change, skipping");
+                            return [2 /*return*/];
+                        }
+                        this.trackingState.isProcessing = true;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 7, 8, 9]);
+                        state = this.getState();
+                        address = this.getConnectedAddress(state);
+                        chainId = state.chainId;
+                        logger.info("WagmiEventHandler: Status changed", {
+                            status: status,
+                            prevStatus: prevStatus,
+                            address: address,
+                            chainId: chainId,
+                        });
+                        if (!(status === "disconnected" && prevStatus === "connected")) return [3 /*break*/, 4];
+                        if (!this.formo.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.formo.disconnect({
+                                chainId: this.trackingState.lastChainId,
+                                address: this.trackingState.lastAddress,
+                            })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        this.trackingState.lastAddress = undefined;
+                        this.trackingState.lastChainId = undefined;
+                        _a.label = 4;
+                    case 4:
+                        if (!(status === "connected" && prevStatus !== "connected")) return [3 /*break*/, 6];
+                        if (!(address && chainId !== undefined)) return [3 /*break*/, 6];
+                        this.trackingState.lastAddress = address;
+                        this.trackingState.lastChainId = chainId;
+                        if (!this.formo.isAutocaptureEnabled("connect")) return [3 /*break*/, 6];
+                        connectorName = this.getConnectorName(state);
+                        return [4 /*yield*/, this.formo.connect({ chainId: chainId, address: address }, __assign({}, (connectorName && { providerName: connectorName })))];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6:
+                        this.trackingState.lastStatus = status;
+                        return [3 /*break*/, 9];
+                    case 7:
+                        error_1 = _a.sent();
+                        logger.error("WagmiEventHandler: Error handling status change:", error_1);
+                        return [3 /*break*/, 9];
+                    case 8:
+                        this.trackingState.isProcessing = false;
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Handle chain ID changes
+     */
+    WagmiEventHandler.prototype.handleChainChange = function (chainId, prevChainId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var state, address, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (chainId === prevChainId || chainId === undefined) {
+                            return [2 /*return*/];
+                        }
+                        state = this.getState();
+                        if (state.status !== "connected") {
+                            return [2 /*return*/];
+                        }
+                        address = this.getConnectedAddress(state);
+                        if (!address) {
+                            logger.warn("WagmiEventHandler: Chain changed but no address found");
+                            return [2 /*return*/];
+                        }
+                        logger.info("WagmiEventHandler: Chain changed", {
+                            chainId: chainId,
+                            prevChainId: prevChainId,
+                            address: address,
+                        });
+                        this.trackingState.lastChainId = chainId;
+                        if (!this.formo.isAutocaptureEnabled("chain")) return [3 /*break*/, 4];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.formo.chain({ chainId: chainId, address: address })];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_2 = _a.sent();
+                        logger.error("WagmiEventHandler: Error tracking chain change:", error_2);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Set up mutation tracking for signatures and transactions
+     */
+    WagmiEventHandler.prototype.setupMutationTracking = function () {
+        var _this = this;
+        if (!this.queryClient) {
+            return;
+        }
+        logger.info("WagmiEventHandler: Setting up mutation tracking");
+        var mutationCache = this.queryClient.getMutationCache();
+        var unsubscribe = mutationCache.subscribe(function (event) {
+            _this.handleMutationEvent(event);
+        });
+        this.unsubscribers.push(unsubscribe);
+        logger.info("WagmiEventHandler: Mutation tracking set up successfully");
+    };
+    /**
+     * Set up query tracking for transaction confirmations
+     * Listens for waitForTransactionReceipt queries to detect CONFIRMED status
+     */
+    WagmiEventHandler.prototype.setupQueryTracking = function () {
+        var _this = this;
+        if (!this.queryClient) {
+            return;
+        }
+        logger.info("WagmiEventHandler: Setting up query tracking");
+        var queryCache = this.queryClient.getQueryCache();
+        var unsubscribe = queryCache.subscribe(function (event) {
+            _this.handleQueryEvent(event);
+        });
+        this.unsubscribers.push(unsubscribe);
+        logger.info("WagmiEventHandler: Query tracking set up successfully");
+    };
+    /**
+     * Handle query cache events (transaction confirmations)
+     */
+    WagmiEventHandler.prototype.handleQueryEvent = function (event) {
+        if (event.type !== "updated") {
+            return;
+        }
+        var query = event.query;
+        var queryKey = query.queryKey;
+        if (!queryKey || queryKey.length === 0) {
+            return;
+        }
+        var queryType = queryKey[0];
+        // Only handle waitForTransactionReceipt queries
+        if (queryType !== "waitForTransactionReceipt") {
+            return;
+        }
+        var state = query.state;
+        // Extract receipt status early to include in deduplication key
+        // This ensures CONFIRMED vs REVERTED outcomes are processed separately
+        var receipt = state.data;
+        var receiptStatus = receipt === null || receipt === void 0 ? void 0 : receipt.status;
+        // Create a unique key for this query state to prevent duplicate processing
+        // Include receipt status to distinguish between CONFIRMED and REVERTED outcomes
+        var queryStateKey = "".concat(query.queryHash, ":").concat(state.status, ":").concat(receiptStatus || "");
+        // Skip if we've already processed this query state
+        if (this.processedQueries.has(queryStateKey)) {
+            logger.debug("WagmiEventHandler: Skipping duplicate query event", {
+                queryType: queryType,
+                queryHash: query.queryHash,
+                status: state.status,
+                receiptStatus: receiptStatus,
+            });
+            return;
+        }
+        // Mark this query state as processed
+        this.processedQueries.add(queryStateKey);
+        logger.debug("WagmiEventHandler: Query event", {
+            queryType: queryType,
+            queryHash: query.queryHash,
+            status: state.status,
+        });
+        // Handle transaction receipt queries
+        this.handleTransactionReceiptQuery(query);
+        // Clean up old processed queries to prevent memory leaks
+        cleanupOldEntries(this.processedQueries);
+    };
+    /**
+     * Handle waitForTransactionReceipt query completion
+     * Emits CONFIRMED or REVERTED transaction status
+     */
+    WagmiEventHandler.prototype.handleTransactionReceiptQuery = function (query) {
+        var _a;
+        if (!this.formo.isAutocaptureEnabled("transaction")) {
+            return;
+        }
+        var state = query.state;
+        var queryKey = query.queryKey;
+        // Only handle successful queries (transaction confirmed on chain)
+        if (state.status !== "success") {
+            return;
+        }
+        // Extract hash and chainId from query key
+        // Query key format: ['waitForTransactionReceipt', { hash, chainId, ... }]
+        var params = queryKey[1];
+        var transactionHash = params === null || params === void 0 ? void 0 : params.hash;
+        var chainId = (params === null || params === void 0 ? void 0 : params.chainId) || this.trackingState.lastChainId;
+        if (!transactionHash) {
+            logger.warn("WagmiEventHandler: Transaction receipt query but no hash found");
+            return;
+        }
+        // Retrieve stored transaction details from BROADCASTED event
+        // Normalize hash to lowercase for consistent lookup
+        var normalizedHash = transactionHash.toLowerCase();
+        var pendingTx = this.pendingTransactions.get(normalizedHash);
+        // Use the original sender address from BROADCASTED event if available,
+        // otherwise fall back to current connected address.
+        // This handles wallet switches between broadcast and confirmation.
+        var address = (pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.address) || this.trackingState.lastAddress;
+        if (!address) {
+            logger.warn("WagmiEventHandler: Transaction receipt query but no address available");
+            return;
+        }
+        try {
+            // Extract receipt data
+            var receipt = state.data;
+            // Determine transaction status from receipt
+            // receipt.status is 'success' or 'reverted' in viem
+            var txStatus = (receipt === null || receipt === void 0 ? void 0 : receipt.status) === "reverted"
+                ? TransactionStatus.REVERTED
+                : TransactionStatus.CONFIRMED;
+            logger.info("WagmiEventHandler: Tracking transaction confirmation", {
+                status: txStatus,
+                transactionHash: transactionHash,
+                address: address,
+                chainId: chainId,
+                blockNumber: (_a = receipt === null || receipt === void 0 ? void 0 : receipt.blockNumber) === null || _a === void 0 ? void 0 : _a.toString(),
+            });
+            this.formo.transaction(__assign(__assign(__assign(__assign(__assign({ status: txStatus, chainId: chainId || 0, address: address, transactionHash: transactionHash }, ((pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.data) && { data: pendingTx.data })), ((pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.to) && { to: pendingTx.to })), ((pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.value) && { value: pendingTx.value })), ((pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.function_name) && { function_name: pendingTx.function_name })), ((pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.function_args) && { function_args: pendingTx.function_args })), 
+            // Spread function args as additional properties (only colliding keys are prefixed)
+            pendingTx === null || pendingTx === void 0 ? void 0 : pendingTx.safeFunctionArgs);
+            // Clean up the pending transaction after confirmation
+            this.pendingTransactions.delete(normalizedHash);
+        }
+        catch (error) {
+            logger.error("WagmiEventHandler: Error handling transaction receipt query:", error);
+        }
+    };
+    /**
+     * Handle mutation cache events (signatures, transactions)
+     */
+    WagmiEventHandler.prototype.handleMutationEvent = function (event) {
+        if (event.type !== "updated") {
+            return;
+        }
+        var mutation = event.mutation;
+        var mutationKey = mutation.options.mutationKey;
+        if (!mutationKey || mutationKey.length === 0) {
+            return;
+        }
+        var mutationType = mutationKey[0];
+        var state = mutation.state;
+        // Create a unique key for this mutation state to prevent duplicate processing
+        var mutationStateKey = "".concat(mutation.mutationId, ":").concat(state.status);
+        // Skip if we've already processed this mutation state
+        if (this.processedMutations.has(mutationStateKey)) {
+            logger.debug("WagmiEventHandler: Skipping duplicate mutation event", {
+                mutationType: mutationType,
+                mutationId: mutation.mutationId,
+                status: state.status,
+            });
+            return;
+        }
+        // Mark this mutation state as processed
+        this.processedMutations.add(mutationStateKey);
+        logger.debug("WagmiEventHandler: Mutation event", {
+            mutationType: mutationType,
+            mutationId: mutation.mutationId,
+            status: state.status,
+        });
+        // Handle signature mutations
+        if (mutationType === "signMessage" || mutationType === "signTypedData") {
+            this.handleSignatureMutation(mutationType, mutation);
+        }
+        // Handle transaction mutations
+        if (mutationType === "sendTransaction" || mutationType === "writeContract") {
+            this.handleTransactionMutation(mutationType, mutation);
+        }
+        // Clean up old processed mutations to prevent memory leaks
+        cleanupOldEntries(this.processedMutations);
+    };
+    /**
+     * Handle signature mutations (signMessage, signTypedData)
+     */
+    WagmiEventHandler.prototype.handleSignatureMutation = function (mutationType, mutation) {
+        if (!this.formo.isAutocaptureEnabled("signature")) {
+            return;
+        }
+        var state = mutation.state;
+        var variables = state.variables || {};
+        var chainId = this.trackingState.lastChainId;
+        var address = this.trackingState.lastAddress;
+        if (!address) {
+            logger.warn("WagmiEventHandler: Signature event but no address available");
+            return;
+        }
+        try {
+            // Map Wagmi mutation status to Formo signature status
+            var status_1;
+            var signatureHash = void 0;
+            if (state.status === "pending") {
+                status_1 = SignatureStatus.REQUESTED;
+            }
+            else if (state.status === "success") {
+                status_1 = SignatureStatus.CONFIRMED;
+                signatureHash = state.data;
+            }
+            else if (state.status === "error") {
+                status_1 = SignatureStatus.REJECTED;
+            }
+            else {
+                return; // Ignore idle state
+            }
+            // Extract message from variables
+            var message = void 0;
+            if (mutationType === "signMessage") {
+                message = variables.message || "";
+            }
+            else {
+                // For signTypedData, stringify the typed data
+                message = JSON.stringify(variables.message || variables.types || {});
+            }
+            logger.info("WagmiEventHandler: Tracking signature event", {
+                status: status_1,
+                mutationType: mutationType,
+                address: address,
+                chainId: chainId,
+            });
+            this.formo.signature(__assign({ status: status_1, chainId: chainId, address: address, message: message }, (signatureHash && { signatureHash: signatureHash })));
+        }
+        catch (error) {
+            logger.error("WagmiEventHandler: Error handling signature mutation:", error);
+        }
+    };
+    /**
+     * Handle transaction mutations (sendTransaction, writeContract)
+     */
+    WagmiEventHandler.prototype.handleTransactionMutation = function (mutationType, mutation) {
+        var _a;
+        if (!this.formo.isAutocaptureEnabled("transaction")) {
+            return;
+        }
+        var state = mutation.state;
+        var variables = state.variables || {};
+        var chainId = this.trackingState.lastChainId || variables.chainId;
+        // For sendTransaction, user's address is the 'from'
+        // For writeContract, variables.address is the contract address, not the user
+        // variables.account can be a string address or an Account object with an address property
+        var accountValue = variables.account;
+        var accountAddress = typeof accountValue === "string"
+            ? accountValue
+            : accountValue === null || accountValue === void 0 ? void 0 : accountValue.address;
+        var userAddress = this.trackingState.lastAddress || accountAddress || variables.from;
+        if (!userAddress) {
+            logger.warn("WagmiEventHandler: Transaction event but no address available");
+            return;
+        }
+        try {
+            // Map Wagmi mutation status to Formo transaction status
+            var status_2;
+            var transactionHash = void 0;
+            if (state.status === "pending") {
+                status_2 = TransactionStatus.STARTED;
+            }
+            else if (state.status === "success") {
+                status_2 = TransactionStatus.BROADCASTED;
+                transactionHash = state.data;
+            }
+            else if (state.status === "error") {
+                status_2 = TransactionStatus.REJECTED;
+            }
+            else {
+                return; // Ignore idle state
+            }
+            // Extract transaction details based on mutation type
+            var data = void 0;
+            var to = void 0;
+            var function_name = void 0;
+            var function_args = void 0;
+            var value = (_a = variables.value) === null || _a === void 0 ? void 0 : _a.toString();
+            if (mutationType === "writeContract") {
+                // For writeContract, extract function info and encode data
+                var abi = variables.abi, fnName = variables.functionName, args = variables.args, contractAddress = variables.address;
+                to = contractAddress;
+                function_name = fnName;
+                if (abi && fnName) {
+                    // Extract function arguments as a name-value map
+                    function_args = extractFunctionArgs(abi, fnName, args);
+                    // Encode the function data synchronously if viem is available
+                    var encodedData = encodeWriteContractData(abi, fnName, args);
+                    if (encodedData) {
+                        data = encodedData;
+                        logger.debug("WagmiEventHandler: Encoded writeContract data", data.substring(0, 10));
+                    }
+                }
+            }
+            else {
+                // For sendTransaction, use variables directly
+                // Only data is available, function_name and function_args are not sent
+                data = variables.data;
+                to = variables.to;
+            }
+            logger.info("WagmiEventHandler: Tracking transaction event", {
+                status: status_2,
+                mutationType: mutationType,
+                address: userAddress,
+                chainId: chainId,
+                transactionHash: transactionHash,
+                function_name: function_name,
+            });
+            // Build safeFunctionArgs with collision handling and struct flattening
+            var safeFunctionArgs = buildSafeFunctionArgs(function_args, RESERVED_FIELDS);
+            // Store transaction details for BROADCASTED status to use in CONFIRMED/REVERTED
+            // Normalize hash to lowercase for consistent lookup
+            // Include the sender address to handle wallet switches between broadcast and confirmation
+            if (status_2 === TransactionStatus.BROADCASTED && transactionHash) {
+                var normalizedHash = transactionHash.toLowerCase();
+                var txDetails = __assign(__assign(__assign(__assign(__assign(__assign({ address: userAddress }, (data && { data: data })), (to && { to: to })), (value && { value: value })), (function_name && { function_name: function_name })), (function_args && { function_args: function_args })), (safeFunctionArgs && { safeFunctionArgs: safeFunctionArgs }));
+                this.pendingTransactions.set(normalizedHash, txDetails);
+                logger.debug("WagmiEventHandler: Stored pending transaction for confirmation", {
+                    transactionHash: normalizedHash,
+                });
+                // Clean up old pending transactions to prevent memory leaks (keep max 100)
+                // Remove oldest 50 entries when limit exceeded to handle high-throughput scenarios
+                if (this.pendingTransactions.size > 100) {
+                    var keys = Array.from(this.pendingTransactions.keys());
+                    for (var i = 0; i < 50 && i < keys.length; i++) {
+                        this.pendingTransactions.delete(keys[i]);
+                    }
+                }
+            }
+            this.formo.transaction(__assign(__assign(__assign(__assign(__assign(__assign({ status: status_2, chainId: chainId || 0, address: userAddress }, (data && { data: data })), (to && { to: to })), (value && { value: value })), (transactionHash && { transactionHash: transactionHash })), (function_name && { function_name: function_name })), (function_args && { function_args: function_args })), 
+            // Spread function args as additional properties (only colliding keys are prefixed)
+            safeFunctionArgs);
+        }
+        catch (error) {
+            logger.error("WagmiEventHandler: Error handling transaction mutation:", error);
+        }
+    };
+    /**
+     * Get the current Wagmi state
+     * Supports both getState() method and direct state property access
+     * for compatibility with different Wagmi wrappers (RainbowKit, etc.)
+     */
+    WagmiEventHandler.prototype.getState = function () {
+        // Try getState() method first (standard Wagmi API)
+        if (typeof this.wagmiConfig.getState === "function") {
+            return this.wagmiConfig.getState();
+        }
+        // Fall back to direct state property (RainbowKit and some Wagmi setups)
+        if (this.wagmiConfig.state) {
+            return this.wagmiConfig.state;
+        }
+        // Return a default disconnected state if neither is available
+        logger.warn("WagmiEventHandler: Unable to get state from config, returning default state");
+        return {
+            status: "disconnected",
+            connections: new Map(),
+            current: undefined,
+            chainId: undefined,
+        };
+    };
+    /**
+     * Get the currently connected address from Wagmi state
+     */
+    WagmiEventHandler.prototype.getConnectedAddress = function (state) {
+        if (!state.current) {
+            return undefined;
+        }
+        var connection = state.connections.get(state.current);
+        if (!connection || connection.accounts.length === 0) {
+            return undefined;
+        }
+        return connection.accounts[0];
+    };
+    /**
+     * Get the connector name from Wagmi state
+     */
+    WagmiEventHandler.prototype.getConnectorName = function (state) {
+        if (!state.current) {
+            return undefined;
+        }
+        var connection = state.connections.get(state.current);
+        return connection === null || connection === void 0 ? void 0 : connection.connector.name;
+    };
+    /**
+     * Clean up all subscriptions
+     */
+    WagmiEventHandler.prototype.cleanup = function () {
+        logger.info("WagmiEventHandler: Cleaning up subscriptions");
+        for (var _i = 0, _a = this.unsubscribers; _i < _a.length; _i++) {
+            var unsubscribe = _a[_i];
+            try {
+                unsubscribe();
+            }
+            catch (error) {
+                logger.error("WagmiEventHandler: Error during cleanup:", error);
+            }
+        }
+        this.unsubscribers = [];
+        this.processedMutations.clear();
+        this.processedQueries.clear();
+        this.pendingTransactions.clear();
+        logger.info("WagmiEventHandler: Cleanup complete");
+    };
+    return WagmiEventHandler;
+}());
+export { WagmiEventHandler };
+//# sourceMappingURL=WagmiEventHandler.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * Wagmi integration module
+ *
+ * Provides integration with Wagmi v2 for wallet event tracking.
+ * This module exports the WagmiEventHandler and related types.
+ */
+export { WagmiEventHandler } from "./WagmiEventHandler";
+export type { WagmiState, WagmiConnection, WagmiConnector, WagmiConfig, MutationState, Mutation, MutationCacheEvent, MutationCache, QueryClient, UnsubscribeFn, WagmiMutationKey, WagmiTrackingState, } from "./types";
+//# sourceMappingURL=index.d.ts.map