@formo/analytics 1.24.0 → 1.26.0

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

@@ -0,0 +1,446 @@
+/**
+ * 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";
+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();
+        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 tracking if QueryClient is provided
+        if (this.queryClient) {
+            this.setupMutationTracking();
+        }
+        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");
+    };
+    /**
+     * 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
+        // Keep only recent mutations (max 1000 entries)
+        if (this.processedMutations.size > 1000) {
+            var entries = Array.from(this.processedMutations);
+            // Remove oldest 500 entries
+            for (var i = 0; i < 500; i++) {
+                this.processedMutations.delete(entries[i]);
+            }
+        }
+    };
+    /**
+     * 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;
+        var address = this.trackingState.lastAddress || variables.account || variables.address;
+        if (!address) {
+            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 from variables
+            var data = variables.data;
+            var to = variables.to || variables.address;
+            var value = (_a = variables.value) === null || _a === void 0 ? void 0 : _a.toString();
+            logger.info("WagmiEventHandler: Tracking transaction event", {
+                status: status_2,
+                mutationType: mutationType,
+                address: address,
+                chainId: chainId,
+                transactionHash: transactionHash,
+            });
+            this.formo.transaction(__assign(__assign(__assign(__assign({ status: status_2, chainId: chainId || 0, address: address }, (data && { data: data })), (to && { to: to })), (value && { value: value })), (transactionHash && { transactionHash: transactionHash })));
+        }
+        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();
+        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

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

@@ -0,0 +1,8 @@
+/**
+ * Wagmi integration module
+ *
+ * Provides integration with Wagmi v2 for wallet event tracking.
+ * This module exports the WagmiEventHandler and related types.
+ */
+export { WagmiEventHandler } from "./WagmiEventHandler";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,115 @@
+/**
+ * Wagmi-specific type definitions for wallet event tracking
+ *
+ * These types provide TypeScript interfaces for Wagmi v2 integration,
+ * allowing the SDK to hook into Wagmi's config.subscribe() and MutationCache
+ * to track wallet events without wrapping EIP-1193 providers.
+ */
+/**
+ * Wagmi config state structure
+ * Based on Wagmi v2 internal state
+ */
+export interface WagmiState {
+    chainId?: number;
+    connections: Map<string, WagmiConnection>;
+    current?: string;
+    status: 'connected' | 'disconnected' | 'connecting' | 'reconnecting';
+}
+/**
+ * Wagmi connection information
+ */
+export interface WagmiConnection {
+    accounts: readonly string[];
+    chainId: number;
+    connector: WagmiConnector;
+}
+/**
+ * Wagmi connector interface
+ */
+export interface WagmiConnector {
+    id: string;
+    name: string;
+    type: string;
+    uid: string;
+}
+/**
+ * Wagmi config interface
+ * This is the config object returned by createConfig() or getDefaultConfig() (RainbowKit)
+ *
+ * Note: Different Wagmi wrappers (RainbowKit, etc.) may expose state differently:
+ * - Some use getState() method
+ * - Some expose state as a direct property
+ * We support both patterns for maximum compatibility.
+ */
+export interface WagmiConfig {
+    subscribe<TData>(selector: (state: WagmiState) => TData, listener: (selectedState: TData, previousSelectedState: TData) => void, options?: {
+        equalityFn?: (a: TData, b: TData) => boolean;
+        fireImmediately?: boolean;
+    }): () => void;
+    /**
+     * Get state method - available in some Wagmi versions
+     */
+    getState?(): WagmiState;
+    /**
+     * Direct state property - available in RainbowKit and some Wagmi setups
+     */
+    state?: WagmiState;
+}
+/**
+ * React Query (TanStack Query) mutation state
+ */
+export interface MutationState {
+    status: 'idle' | 'pending' | 'success' | 'error';
+    data?: any;
+    error?: Error | null;
+    variables?: any;
+    context?: any;
+}
+/**
+ * React Query mutation object
+ */
+export interface Mutation {
+    state: MutationState;
+    options: {
+        mutationKey?: readonly unknown[];
+        [key: string]: any;
+    };
+    mutationId: number;
+}
+/**
+ * React Query mutation cache event
+ */
+export interface MutationCacheEvent {
+    type: 'added' | 'removed' | 'updated';
+    mutation: Mutation;
+}
+/**
+ * React Query MutationCache interface
+ */
+export interface MutationCache {
+    subscribe(listener: (event: MutationCacheEvent) => void): () => void;
+}
+/**
+ * React Query QueryClient interface
+ */
+export interface QueryClient {
+    getMutationCache(): MutationCache;
+}
+/**
+ * Unsubscribe function returned by subscriptions
+ */
+export type UnsubscribeFn = () => void;
+/**
+ * Wagmi mutation key types for identifying wallet operations
+ */
+export type WagmiMutationKey = 'signMessage' | 'signTypedData' | 'sendTransaction' | 'writeContract';
+/**
+ * Internal tracking state for Wagmi event handler
+ */
+export interface WagmiTrackingState {
+    lastChainId?: number;
+    lastAddress?: string;
+    lastStatus?: WagmiState['status'];
+    isProcessing: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * Wagmi-specific type definitions for wallet event tracking
+ *
+ * These types provide TypeScript interfaces for Wagmi v2 integration,
+ * allowing the SDK to hook into Wagmi's config.subscribe() and MutationCache
+ * to track wallet events without wrapping EIP-1193 providers.
+ */
+export {};
+//# sourceMappingURL=types.js.map