@formo/analytics 1.20.0 → 1.22.0

package/dist/cjs/src/FormoAnalytics.js

@@ -71,7 +71,7 @@ var chain_1 = require("./utils/chain");
 var PROVIDER_SWITCH_REASONS = {
     ADDRESS_MISMATCH: "Address mismatch indicates wallet switch",
     NO_ACCOUNTS: "Current provider has no accounts",
-    CHECK_FAILED: "Could not check current provider accounts"
+    CHECK_FAILED: "Could not check current provider accounts",
 };
 var FormoAnalytics = /** @class */ (function () {
     function FormoAnalytics(writeKey, options) {
@@ -114,6 +114,7 @@ var FormoAnalytics = /** @class */ (function () {
         this.transaction = this.transaction.bind(this);
         this.detect = this.detect.bind(this);
         this.track = this.track.bind(this);
+        this.isAutocaptureEnabled = this.isAutocaptureEnabled.bind(this);
         // Initialize logger with configuration from options
         lib_1.Logger.init({
             enabled: ((_a = options.logger) === null || _a === void 0 ? void 0 : _a.enabled) || false,
@@ -136,7 +137,7 @@ var FormoAnalytics = /** @class */ (function () {
         if (optProvider) {
             provider = optProvider;
         }
-        else if (typeof window !== 'undefined' && window.ethereum) {
+        else if (typeof window !== "undefined" && window.ethereum) {
             provider = window.ethereum;
         }
         if (provider) {
@@ -163,9 +164,9 @@ var FormoAnalytics = /** @class */ (function () {
     FormoAnalytics.prototype.isProviderInValidState = function (provider) {
         // Basic validation: ensure provider exists and has required methods
         return (provider &&
-            typeof provider.request === 'function' &&
-            typeof provider.on === 'function' &&
-            typeof provider.removeListener === 'function');
+            typeof provider.request === "function" &&
+            typeof provider.on === "function" &&
+            typeof provider.removeListener === "function");
     };
     FormoAnalytics.init = function (writeKey, options) {
         return __awaiter(this, void 0, void 0, function () {
@@ -284,16 +285,18 @@ var FormoAnalytics = /** @class */ (function () {
                     case 0:
                         chainId = (params === null || params === void 0 ? void 0 : params.chainId) || this.currentChainId;
                         address = (params === null || params === void 0 ? void 0 : params.address) || this.currentAddress;
-                        providerInfo = this._provider ? this.getProviderInfo(this._provider) : null;
+                        providerInfo = this._provider
+                            ? this.getProviderInfo(this._provider)
+                            : null;
                         lib_1.logger.info("Disconnect: Emitting disconnect event with:", {
                             chainId: chainId,
                             address: address,
                             providerName: providerInfo === null || providerInfo === void 0 ? void 0 : providerInfo.name,
-                            rdns: providerInfo === null || providerInfo === void 0 ? void 0 : providerInfo.rdns
+                            rdns: providerInfo === null || providerInfo === void 0 ? void 0 : providerInfo.rdns,
                         });
                         disconnectProperties = __assign(__assign({}, (providerInfo && {
                             providerName: providerInfo.name,
-                            rdns: providerInfo.rdns
+                            rdns: providerInfo.rdns,
                         })), properties);
                         return [4 /*yield*/, this.trackEvent(constants_1.EventType.DISCONNECT, __assign(__assign({}, (chainId && { chainId: chainId })), (address && { address: address })), disconnectProperties, context, callback)];
                     case 1:
@@ -440,9 +443,12 @@ var FormoAnalytics = /** @class */ (function () {
                             validAddress: validAddress_1,
                             rdns: providerDetail.info.rdns,
                             providerName: providerDetail.info.name,
-                            isAlreadyIdentified: validAddress_1 ? this.session.isWalletIdentified(validAddress_1, providerDetail.info.rdns) : false
+                            isAlreadyIdentified: validAddress_1
+                                ? this.session.isWalletIdentified(validAddress_1, providerDetail.info.rdns)
+                                : false,
                         });
-                        if (!(validAddress_1 && !this.session.isWalletIdentified(validAddress_1, providerDetail.info.rdns))) return [3 /*break*/, 5];
+                        if (!(validAddress_1 &&
+                            !this.session.isWalletIdentified(validAddress_1, providerDetail.info.rdns))) return [3 /*break*/, 5];
                         lib_1.logger.info("Auto-identifying", validAddress_1, providerDetail.info.name, providerDetail.info.rdns);
                         // NOTE: do not set this.currentAddress without explicit connect or identify
                         return [4 /*yield*/, this.identify({
@@ -486,23 +492,25 @@ var FormoAnalytics = /** @class */ (function () {
                             this.currentUserId = userId;
                             (0, lib_1.cookie)().set(constants_1.SESSION_USER_ID_KEY, userId);
                         }
-                        isAlreadyIdentified = validAddress ? this.session.isWalletIdentified(validAddress, rdns || '') : false;
+                        isAlreadyIdentified = validAddress
+                            ? this.session.isWalletIdentified(validAddress, rdns || "")
+                            : false;
                         lib_1.logger.debug("Identify: Checking deduplication", {
                             validAddress: validAddress,
                             rdns: rdns,
                             providerName: providerName,
                             hasValidAddress: !!validAddress,
                             hasRdns: !!rdns,
-                            isAlreadyIdentified: isAlreadyIdentified
+                            isAlreadyIdentified: isAlreadyIdentified,
                         });
                         if (isAlreadyIdentified) {
-                            lib_1.logger.info("Identify: Wallet ".concat(providerName || 'Unknown', " with address ").concat(validAddress, " already identified in this session (rdns: ").concat(rdns || 'empty', ")"));
+                            lib_1.logger.info("Identify: Wallet ".concat(providerName || "Unknown", " with address ").concat(validAddress, " already identified in this session (rdns: ").concat(rdns || "empty", ")"));
                             return [2 /*return*/];
                         }
                         // Mark as identified before emitting the event
                         // Mark even if rdns is empty to prevent duplicate empty identifies
                         if (validAddress) {
-                            this.session.markWalletIdentified(validAddress, rdns || '');
+                            this.session.markWalletIdentified(validAddress, rdns || "");
                         }
                         return [4 /*yield*/, this.trackEvent(constants_1.EventType.IDENTIFY, {
                                 address: validAddress,
@@ -616,12 +624,26 @@ var FormoAnalytics = /** @class */ (function () {
                 lib_1.logger.warn("TrackProvider: Provider already tracked.");
                 return;
             }
-            // Register listeners for this provider first
+            // CRITICAL: Always register accountsChanged for state management
+            // This ensures currentAddress, currentChainId, and _provider are always up-to-date
+            // Event emission is controlled conditionally inside the handlers
             this.registerAccountsChangedListener(provider);
-            this.registerChainChangedListener(provider);
-            this.registerConnectListener(provider);
-            this.registerRequestListeners(provider);
-            this.registerDisconnectListener(provider);
+            // Register other listeners based on autocapture configuration
+            if (this.isAutocaptureEnabled("chain")) {
+                this.registerChainChangedListener(provider);
+            }
+            if (this.isAutocaptureEnabled("connect")) {
+                this.registerConnectListener(provider);
+            }
+            if (this.isAutocaptureEnabled("signature") || this.isAutocaptureEnabled("transaction")) {
+                this.registerRequestListeners(provider);
+            }
+            else {
+                lib_1.logger.debug("TrackProvider: Skipping request wrapping (both signature and transaction autocapture disabled)");
+            }
+            if (this.isAutocaptureEnabled("disconnect")) {
+                this.registerDisconnectListener(provider);
+            }
             // Only add to tracked providers after all listeners are successfully registered
             this._trackedProviders.add(provider);
         }
@@ -670,7 +692,7 @@ var FormoAnalytics = /** @class */ (function () {
                         // Prevent concurrent processing of accountsChanged events to avoid race conditions
                         if (this._processingAccountsChanged) {
                             lib_1.logger.debug("OnAccountsChanged: Already processing accountsChanged, skipping", {
-                                provider: this.getProviderInfo(provider).name
+                                provider: this.getProviderInfo(provider).name,
                             });
                             return [2 /*return*/];
                         }
@@ -706,20 +728,21 @@ var FormoAnalytics = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!(accounts.length === 0)) return [3 /*break*/, 7];
-                        if (!(this._provider === provider)) return [3 /*break*/, 5];
+                        if (!(accounts.length === 0)) return [3 /*break*/, 9];
+                        if (!(this._provider === provider)) return [3 /*break*/, 7];
                         lib_1.logger.info("OnAccountsChanged: Detecting disconnect, current state:", {
                             currentAddress: this.currentAddress,
                             currentChainId: this.currentChainId,
-                            providerMatch: this._provider === provider
+                            providerMatch: this._provider === provider,
                         });
+                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 5];
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 3, , 4]);
                         // Pass current state explicitly to ensure we have the data for the disconnect event
                         return [4 /*yield*/, this.disconnect({
                                 chainId: this.currentChainId,
-                                address: this.currentAddress
+                                address: this.currentAddress,
                             })];
                     case 2:
                         // Pass current state explicitly to ensure we have the data for the disconnect event
@@ -731,103 +754,138 @@ var FormoAnalytics = /** @class */ (function () {
                         return [3 /*break*/, 4];
                     case 4: return [3 /*break*/, 6];
                     case 5:
-                        lib_1.logger.info("OnAccountsChanged: Ignoring disconnect for non-active provider");
+                        lib_1.logger.debug("OnAccountsChanged: Disconnect event skipped (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.currentAddress = undefined;
+                        this.currentChainId = undefined;
+                        this.clearActiveProvider();
                         _a.label = 6;
-                    case 6: return [2 /*return*/];
+                    case 6: return [3 /*break*/, 8];
                     case 7:
+                        lib_1.logger.info("OnAccountsChanged: Ignoring disconnect for non-active provider");
+                        _a.label = 8;
+                    case 8: return [2 /*return*/];
+                    case 9:
                         address = this.validateAndChecksumAddress(accounts[0]);
                         if (!address) {
                             lib_1.logger.warn("onAccountsChanged: Invalid address received", accounts[0]);
                             return [2 /*return*/];
                         }
-                        if (!(this._provider && this._provider !== provider)) return [3 /*break*/, 18];
+                        if (!(this._provider && this._provider !== provider)) return [3 /*break*/, 26];
                         currentStoredAddress = this.currentAddress;
                         newProviderAddress = this.validateAndChecksumAddress(address);
                         lib_1.logger.info("OnAccountsChanged: Different provider attempting to connect", {
                             activeProvider: this.getProviderInfo(this._provider).name,
                             eventProvider: this.getProviderInfo(provider).name,
                             currentStoredAddress: currentStoredAddress,
-                            newProviderAddress: newProviderAddress
+                            newProviderAddress: newProviderAddress,
                         });
-                        _a.label = 8;
-                    case 8:
-                        _a.trys.push([8, 16, , 18]);
+                        _a.label = 10;
+                    case 10:
+                        _a.trys.push([10, 22, , 26]);
                         return [4 /*yield*/, this.getAccounts(this._provider)];
-                    case 9:
+                    case 11:
                         activeProviderAccounts = _a.sent();
                         lib_1.logger.info("OnAccountsChanged: Checking current provider accounts", {
                             activeProvider: this.getProviderInfo(this._provider).name,
-                            accountsLength: activeProviderAccounts ? activeProviderAccounts.length : 0,
-                            accounts: activeProviderAccounts
+                            accountsLength: activeProviderAccounts
+                                ? activeProviderAccounts.length
+                                : 0,
+                            accounts: activeProviderAccounts,
                         });
-                        if (!(activeProviderAccounts && activeProviderAccounts.length > 0)) return [3 /*break*/, 13];
-                        if (!(newProviderAddress && currentStoredAddress && newProviderAddress !== currentStoredAddress)) return [3 /*break*/, 11];
+                        if (!(activeProviderAccounts && activeProviderAccounts.length > 0)) return [3 /*break*/, 17];
+                        if (!(newProviderAddress &&
+                            currentStoredAddress &&
+                            newProviderAddress !== currentStoredAddress)) return [3 /*break*/, 15];
                         lib_1.logger.info("OnAccountsChanged: Different address detected, switching providers despite current provider having accounts", {
                             activeProvider: this.getProviderInfo(this._provider).name,
                             eventProvider: this.getProviderInfo(provider).name,
                             currentAddress: currentStoredAddress,
                             newAddress: newProviderAddress,
-                            reason: PROVIDER_SWITCH_REASONS.ADDRESS_MISMATCH
+                            reason: PROVIDER_SWITCH_REASONS.ADDRESS_MISMATCH,
                         });
-                        // Emit disconnect for the old provider
+                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 13];
                         return [4 /*yield*/, this.disconnect({
                                 chainId: this.currentChainId,
-                                address: this.currentAddress
+                                address: this.currentAddress,
                             })];
-                    case 10:
-                        // Emit disconnect for the old provider
+                    case 12:
                         _a.sent();
+                        return [3 /*break*/, 14];
+                    case 13:
+                        lib_1.logger.debug("OnAccountsChanged: Disconnect event skipped during provider switch (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.currentAddress = undefined;
+                        this.currentChainId = undefined;
+                        _a.label = 14;
+                    case 14:
                         // Clear state and let the new provider become active
                         this.clearActiveProvider();
-                        return [3 /*break*/, 12];
-                    case 11:
+                        return [3 /*break*/, 16];
+                    case 15:
                         lib_1.logger.info("OnAccountsChanged: Current provider still has accounts and same address, ignoring new provider", {
                             activeProvider: this.getProviderInfo(this._provider).name,
                             eventProvider: this.getProviderInfo(provider).name,
                             activeProviderAccountsCount: activeProviderAccounts.length,
                             currentAddress: currentStoredAddress,
-                            newAddress: newProviderAddress
+                            newAddress: newProviderAddress,
                         });
                         return [2 /*return*/];
-                    case 12: return [3 /*break*/, 15];
-                    case 13:
+                    case 16: return [3 /*break*/, 21];
+                    case 17:
                         lib_1.logger.info("OnAccountsChanged: Current provider has no accounts, switching to new provider", {
                             oldProvider: this.getProviderInfo(this._provider).name,
                             newProvider: this.getProviderInfo(provider).name,
-                            reason: PROVIDER_SWITCH_REASONS.NO_ACCOUNTS
+                            reason: PROVIDER_SWITCH_REASONS.NO_ACCOUNTS,
                         });
-                        // Emit disconnect for the old provider that didn't signal properly
+                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 19];
                         return [4 /*yield*/, this.disconnect({
                                 chainId: this.currentChainId,
-                                address: this.currentAddress
+                                address: this.currentAddress,
                             })];
-                    case 14:
-                        // Emit disconnect for the old provider that didn't signal properly
+                    case 18:
                         _a.sent();
+                        return [3 /*break*/, 20];
+                    case 19:
+                        lib_1.logger.debug("OnAccountsChanged: Disconnect event skipped for old provider (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.currentAddress = undefined;
+                        this.currentChainId = undefined;
+                        _a.label = 20;
+                    case 20:
                         // Clear state and let the new provider become active
                         this.clearActiveProvider();
-                        _a.label = 15;
-                    case 15: return [3 /*break*/, 18];
-                    case 16:
+                        _a.label = 21;
+                    case 21: return [3 /*break*/, 26];
+                    case 22:
                         error_2 = _a.sent();
                         lib_1.logger.warn("OnAccountsChanged: Could not check current provider accounts, switching to new provider", {
                             error: error_2 instanceof Error ? error_2.message : String(error_2),
                             errorType: error_2 instanceof Error ? error_2.constructor.name : typeof error_2,
-                            oldProvider: this._provider ? this.getProviderInfo(this._provider).name : 'unknown',
+                            oldProvider: this._provider
+                                ? this.getProviderInfo(this._provider).name
+                                : "unknown",
                             newProvider: this.getProviderInfo(provider).name,
-                            reason: PROVIDER_SWITCH_REASONS.CHECK_FAILED
+                            reason: PROVIDER_SWITCH_REASONS.CHECK_FAILED,
                         });
-                        // If we can't check the current provider, assume it's disconnected
+                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 24];
                         return [4 /*yield*/, this.disconnect({
                                 chainId: this.currentChainId,
-                                address: this.currentAddress
+                                address: this.currentAddress,
                             })];
-                    case 17:
-                        // If we can't check the current provider, assume it's disconnected
+                    case 23:
                         _a.sent();
+                        return [3 /*break*/, 25];
+                    case 24:
+                        lib_1.logger.debug("OnAccountsChanged: Disconnect event skipped for failed provider check (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.currentAddress = undefined;
+                        this.currentChainId = undefined;
+                        _a.label = 25;
+                    case 25:
                         this.clearActiveProvider();
-                        return [3 /*break*/, 18];
-                    case 18:
+                        return [3 /*break*/, 26];
+                    case 26:
                         // Set provider if none exists (first connection)
                         if (!this._provider) {
                             this._provider = provider;
@@ -837,33 +895,44 @@ var FormoAnalytics = /** @class */ (function () {
                             return [2 /*return*/];
                         }
                         return [4 /*yield*/, this.getCurrentChainId(provider)];
-                    case 19:
+                    case 27:
                         nextChainId = _a.sent();
                         wasDisconnected = !this.currentAddress;
+                        // CRITICAL: Always update state regardless of whether connect tracking is enabled
+                        // This ensures disconnect events will have valid address/chainId values
                         this.currentAddress = address;
                         this.currentChainId = nextChainId;
                         providerInfo = this.getProviderInfo(provider);
-                        lib_1.logger.info("OnAccountsChanged: Detected wallet connection, emitting connect event", {
-                            chainId: nextChainId,
-                            address: address,
-                            wasDisconnected: wasDisconnected,
-                            providerName: providerInfo.name,
-                            rdns: providerInfo.rdns,
-                            hasChainId: !!nextChainId
-                        });
                         effectiveChainId = nextChainId || 0;
-                        if (effectiveChainId === 0) {
-                            lib_1.logger.info("OnAccountsChanged: Using fallback chainId 0 for connect event");
+                        if (this.isAutocaptureEnabled("connect")) {
+                            lib_1.logger.info("OnAccountsChanged: Detected wallet connection, emitting connect event", {
+                                chainId: nextChainId,
+                                address: address,
+                                wasDisconnected: wasDisconnected,
+                                providerName: providerInfo.name,
+                                rdns: providerInfo.rdns,
+                                hasChainId: !!nextChainId,
+                            });
+                            if (effectiveChainId === 0) {
+                                lib_1.logger.info("OnAccountsChanged: Using fallback chainId 0 for connect event");
+                            }
+                            this.connect({
+                                chainId: effectiveChainId,
+                                address: address,
+                            }, {
+                                providerName: providerInfo.name,
+                                rdns: providerInfo.rdns,
+                            }).catch(function (error) {
+                                lib_1.logger.error("Failed to track connect event during account change:", error);
+                            });
+                        }
+                        else {
+                            lib_1.logger.debug("OnAccountsChanged: Connect event skipped (autocapture.connect: false)", {
+                                chainId: nextChainId,
+                                address: address,
+                                providerName: providerInfo.name,
+                            });
                         }
-                        this.connect({
-                            chainId: effectiveChainId,
-                            address: address
-                        }, {
-                            providerName: providerInfo.name,
-                            rdns: providerInfo.rdns
-                        }).catch(function (error) {
-                            lib_1.logger.error("Failed to track connect event during account change:", error);
-                        });
                         return [2 /*return*/];
                 }
             });
@@ -904,10 +973,18 @@ var FormoAnalytics = /** @class */ (function () {
                 this.currentChainId = nextChainId;
                 try {
                     // This is just a chain change since we already confirmed currentAddress exists
-                    return [2 /*return*/, this.chain({
+                    if (this.isAutocaptureEnabled("chain")) {
+                        return [2 /*return*/, this.chain({
+                                chainId: this.currentChainId,
+                                address: this.currentAddress,
+                            })];
+                    }
+                    else {
+                        lib_1.logger.debug("OnChainChanged: Chain event skipped (autocapture.chain: false)", {
                             chainId: this.currentChainId,
                             address: this.currentAddress,
-                        })];
+                        });
+                    }
                 }
                 catch (error) {
                     lib_1.logger.error("OnChainChanged: Failed to emit chain event:", error);
@@ -942,15 +1019,16 @@ var FormoAnalytics = /** @class */ (function () {
                             return [2 /*return*/];
                         lib_1.logger.info("OnDisconnect: Wallet disconnect event received, current state:", {
                             currentAddress: this.currentAddress,
-                            currentChainId: this.currentChainId
+                            currentChainId: this.currentChainId,
                         });
+                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 5];
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 3, , 4]);
                         // Pass current state explicitly to ensure we have the data for the disconnect event
                         return [4 /*yield*/, this.disconnect({
                                 chainId: this.currentChainId,
-                                address: this.currentAddress
+                                address: this.currentAddress,
                             })];
                     case 2:
                         // Pass current state explicitly to ensure we have the data for the disconnect event
@@ -960,7 +1038,15 @@ var FormoAnalytics = /** @class */ (function () {
                         e_2 = _a.sent();
                         lib_1.logger.error("Error during disconnect in disconnect listener", e_2);
                         return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        lib_1.logger.debug("OnDisconnect: Disconnect event skipped (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.currentAddress = undefined;
+                        this.currentChainId = undefined;
+                        this.clearActiveProvider();
+                        _a.label = 6;
+                    case 6: return [2 /*return*/];
                 }
             });
         }); };
@@ -977,7 +1063,7 @@ var FormoAnalytics = /** @class */ (function () {
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 3, , 4]);
-                        if (!(connection === null || connection === void 0 ? void 0 : connection.chainId) || typeof connection.chainId !== 'string')
+                        if (!(connection === null || connection === void 0 ? void 0 : connection.chainId) || typeof connection.chainId !== "string")
                             return [2 /*return*/];
                         chainId = (0, chain_1.parseChainId)(connection.chainId);
                         return [4 /*yield*/, this.getAddress(provider)];
@@ -990,34 +1076,46 @@ var FormoAnalytics = /** @class */ (function () {
                                 this._provider = provider;
                             }
                             isActiveProvider = this._provider === provider;
-                            // Only update global state (chainId/address) from the active provider
+                            // CRITICAL: Always update state from active provider regardless of tracking config
+                            // This ensures disconnect events will have valid address/chainId values
                             if (isActiveProvider) {
                                 this.currentChainId = chainId;
-                                this.currentAddress = this.validateAndChecksumAddress(address) || undefined;
+                                this.currentAddress =
+                                    this.validateAndChecksumAddress(address) || undefined;
                             }
+                            // Conditionally emit connect event based on tracking configuration
                             if (isActiveProvider && this.currentAddress) {
                                 providerInfo = this.getProviderInfo(provider);
-                                lib_1.logger.info("OnConnected: Detected wallet connection, emitting connect event", {
-                                    chainId: chainId,
-                                    wasDisconnected: wasDisconnected,
-                                    providerName: providerInfo.name,
-                                    rdns: providerInfo.rdns,
-                                    hasChainId: !!chainId,
-                                    isActiveProvider: isActiveProvider
-                                });
                                 effectiveChainId = chainId || 0;
-                                if (effectiveChainId === 0) {
-                                    lib_1.logger.info("OnConnected: Using fallback chainId 0 for connect event");
+                                if (this.isAutocaptureEnabled("connect")) {
+                                    lib_1.logger.info("OnConnected: Detected wallet connection, emitting connect event", {
+                                        chainId: chainId,
+                                        wasDisconnected: wasDisconnected,
+                                        providerName: providerInfo.name,
+                                        rdns: providerInfo.rdns,
+                                        hasChainId: !!chainId,
+                                        isActiveProvider: isActiveProvider,
+                                    });
+                                    if (effectiveChainId === 0) {
+                                        lib_1.logger.info("OnConnected: Using fallback chainId 0 for connect event");
+                                    }
+                                    this.connect({
+                                        chainId: effectiveChainId,
+                                        address: address,
+                                    }, {
+                                        providerName: providerInfo.name,
+                                        rdns: providerInfo.rdns,
+                                    }).catch(function (error) {
+                                        lib_1.logger.error("Failed to track connect event during provider connection:", error);
+                                    });
+                                }
+                                else {
+                                    lib_1.logger.debug("OnConnected: Connect event skipped (autocapture.connect: false)", {
+                                        chainId: chainId,
+                                        address: address,
+                                        providerName: providerInfo.name,
+                                    });
                                 }
-                                this.connect({
-                                    chainId: effectiveChainId,
-                                    address: address
-                                }, {
-                                    providerName: providerInfo.name,
-                                    rdns: providerInfo.rdns
-                                }).catch(function (error) {
-                                    lib_1.logger.error("Failed to track connect event during provider connection:", error);
-                                });
                             }
                             else if (address && !isActiveProvider) {
                                 providerInfo = this.getProviderInfo(provider);
@@ -1026,7 +1124,9 @@ var FormoAnalytics = /** @class */ (function () {
                                     providerName: providerInfo.name,
                                     rdns: providerInfo.rdns,
                                     isActiveProvider: isActiveProvider,
-                                    activeProviderInfo: this._provider ? this.getProviderInfo(this._provider) : null
+                                    activeProviderInfo: this._provider
+                                        ? this.getProviderInfo(this._provider)
+                                        : null,
                                 });
                             }
                         }
@@ -1063,6 +1163,10 @@ var FormoAnalytics = /** @class */ (function () {
                     case 0:
                         if (!(Array.isArray(params) &&
                             ["eth_signTypedData_v4", "personal_sign"].includes(method))) return [3 /*break*/, 6];
+                        if (!this.isAutocaptureEnabled("signature")) {
+                            lib_1.logger.debug("Signature event skipped (autocapture.signature: false)", { method: method });
+                            return [2 /*return*/, request({ method: method, params: params })];
+                        }
                         _c = this.currentChainId;
                         if (_c) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.getCurrentChainId(provider)];
@@ -1126,6 +1230,10 @@ var FormoAnalytics = /** @class */ (function () {
                         if (!(Array.isArray(params) &&
                             method === "eth_sendTransaction" &&
                             params[0])) return [3 /*break*/, 10];
+                        if (!this.isAutocaptureEnabled("transaction")) {
+                            lib_1.logger.debug("Transaction event skipped (autocapture.transaction: false)", { method: method });
+                            return [2 /*return*/, request({ method: method, params: params })];
+                        }
                         (function () { return __awaiter(_this, void 0, void 0, function () {
                             var payload, e_4;
                             return __generator(this, function (_a) {
@@ -1208,7 +1316,8 @@ var FormoAnalytics = /** @class */ (function () {
         }); };
         // Mark the wrapper so we can detect if request is replaced externally and keep a reference on provider
         wrappedRequest[types_1.WRAPPED_REQUEST_SYMBOL] = true;
-        provider[types_1.WRAPPED_REQUEST_REF_SYMBOL] = wrappedRequest;
+        provider[types_1.WRAPPED_REQUEST_REF_SYMBOL] =
+            wrappedRequest;
         try {
             // Attempt to assign the wrapped request function (rely on try-catch for mutability errors)
             provider.request = wrappedRequest;
@@ -1298,18 +1407,25 @@ var FormoAnalytics = /** @class */ (function () {
     };
     FormoAnalytics.prototype.trackEvent = function (type, payload, properties, context, callback) {
         return __awaiter(this, void 0, void 0, function () {
+            var error_5;
             return __generator(this, function (_a) {
-                try {
-                    if (!this.shouldTrack()) {
-                        lib_1.logger.info("Skipping ".concat(type, " event due to tracking configuration"));
-                        return [2 /*return*/];
-                    }
-                    this.eventManager.addEvent(__assign(__assign({ type: type }, payload), { properties: properties, context: context, callback: callback }), this.currentAddress, this.currentUserId);
-                }
-                catch (error) {
-                    lib_1.logger.error("Error tracking event:", error);
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        if (!this.shouldTrack()) {
+                            lib_1.logger.info("Skipping ".concat(type, " event due to tracking configuration"));
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.eventManager.addEvent(__assign(__assign({ type: type }, payload), { properties: properties, context: context, callback: callback }), this.currentAddress, this.currentUserId)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_5 = _a.sent();
+                        lib_1.logger.error("Error tracking event:", error_5);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
                 }
-                return [2 /*return*/];
             });
         });
     };
@@ -1323,23 +1439,23 @@ var FormoAnalytics = /** @class */ (function () {
             return false;
         }
         // Check if tracking is explicitly provided as a boolean
-        if (typeof this.options.tracking === 'boolean') {
+        if (typeof this.options.tracking === "boolean") {
             return this.options.tracking;
         }
         // Handle object configuration with exclusion rules
         if (this.options.tracking !== null &&
-            typeof this.options.tracking === 'object' &&
+            typeof this.options.tracking === "object" &&
             !Array.isArray(this.options.tracking)) {
             var _a = this.options.tracking, _b = _a.excludeHosts, excludeHosts = _b === void 0 ? [] : _b, _c = _a.excludePaths, excludePaths = _c === void 0 ? [] : _c, _d = _a.excludeChains, excludeChains = _d === void 0 ? [] : _d;
             // Check hostname exclusions - use exact matching
-            if (excludeHosts.length > 0 && typeof window !== 'undefined') {
+            if (excludeHosts.length > 0 && typeof window !== "undefined") {
                 var hostname = window.location.hostname;
                 if (excludeHosts.includes(hostname)) {
                     return false;
                 }
             }
             // Check path exclusions - use exact matching
-            if (excludePaths.length > 0 && typeof window !== 'undefined') {
+            if (excludePaths.length > 0 && typeof window !== "undefined") {
                 var pathname = window.location.pathname;
                 if (excludePaths.includes(pathname)) {
                     return false;
@@ -1357,6 +1473,30 @@ var FormoAnalytics = /** @class */ (function () {
         // Default behavior: track everywhere except localhost
         return !(0, validators_1.isLocalhost)();
     };
+    /**
+     * Check if a specific wallet event type is enabled for autocapture
+     * @param eventType The wallet event type to check
+     * @returns {boolean} True if the event type should be autocaptured
+     */
+    FormoAnalytics.prototype.isAutocaptureEnabled = function (eventType) {
+        // If no configuration provided, default to enabled
+        if (this.options.autocapture === undefined) {
+            return true;
+        }
+        // If boolean, return that value for all events
+        if (typeof this.options.autocapture === "boolean") {
+            return this.options.autocapture;
+        }
+        // If it's an object, check the specific event configuration
+        if (this.options.autocapture !== null &&
+            typeof this.options.autocapture === "object") {
+            var eventConfig = this.options.autocapture[eventType];
+            // Default to true if not explicitly set to false
+            return eventConfig !== false;
+        }
+        // Default to enabled if no specific configuration
+        return true;
+    };
     /*
       Utility functions
     */
@@ -1371,14 +1511,14 @@ var FormoAnalytics = /** @class */ (function () {
         if (eip6963Provider) {
             return {
                 name: eip6963Provider.info.name,
-                rdns: eip6963Provider.info.rdns
+                rdns: eip6963Provider.info.rdns,
             };
         }
         // Fallback to injected provider detection
         var injectedInfo = this.detectInjectedProviderInfo(provider);
         return {
             name: injectedInfo.name,
-            rdns: injectedInfo.rdns
+            rdns: injectedInfo.rdns,
         };
     };
     /**
@@ -1388,45 +1528,45 @@ var FormoAnalytics = /** @class */ (function () {
      */
     FormoAnalytics.prototype.detectInjectedProviderInfo = function (provider) {
         // Try to detect provider type from common properties
-        var name = 'Injected Provider';
-        var rdns = 'io.injected.provider';
+        var name = "Injected Provider";
+        var rdns = "io.injected.provider";
         // Use WalletProviderFlags interface for type safety
         var flags = provider;
         // Check if it's MetaMask
         if (flags.isMetaMask) {
-            name = 'MetaMask';
-            rdns = 'io.metamask';
+            name = "MetaMask";
+            rdns = "io.metamask";
         }
         // Check if it's Coinbase Wallet
         else if (flags.isCoinbaseWallet) {
-            name = 'Coinbase Wallet';
-            rdns = 'com.coinbase.wallet';
+            name = "Coinbase Wallet";
+            rdns = "com.coinbase.wallet";
         }
         // Check if it's WalletConnect
         else if (flags.isWalletConnect) {
-            name = 'WalletConnect';
-            rdns = 'com.walletconnect';
+            name = "WalletConnect";
+            rdns = "com.walletconnect";
         }
         // Check if it's Trust Wallet
         else if (flags.isTrust) {
-            name = 'Trust Wallet';
-            rdns = 'com.trustwallet';
+            name = "Trust Wallet";
+            rdns = "com.trustwallet";
         }
         // Check if it's Brave Wallet
         else if (flags.isBraveWallet) {
-            name = 'Brave Wallet';
-            rdns = 'com.brave.wallet';
+            name = "Brave Wallet";
+            rdns = "com.brave.wallet";
         }
         // Check if it's Phantom
         else if (flags.isPhantom) {
-            name = 'Phantom';
-            rdns = 'app.phantom';
+            name = "Phantom";
+            rdns = "app.phantom";
         }
         return {
             name: name,
             rdns: rdns,
-            uuid: "injected-".concat(rdns.replace(/[^a-zA-Z0-9]/g, '-')),
-            icon: constants_1.DEFAULT_PROVIDER_ICON
+            uuid: "injected-".concat(rdns.replace(/[^a-zA-Z0-9]/g, "-")),
+            icon: constants_1.DEFAULT_PROVIDER_ICON,
         };
     };
     FormoAnalytics.prototype.getProviders = function () {
@@ -1480,7 +1620,7 @@ var FormoAnalytics = /** @class */ (function () {
                 });
                 // Fallback to injected provider if no providers are found
                 if (providers.length === 0) {
-                    injected_1 = typeof window !== 'undefined' ? window.ethereum : undefined;
+                    injected_1 = typeof window !== "undefined" ? window.ethereum : undefined;
                     if (injected_1) {
                         // If we have already detected and cached the injected provider, and it's the same instance, return the cached result
                         if (this._injectedProviderDetail &&
@@ -1491,7 +1631,9 @@ var FormoAnalytics = /** @class */ (function () {
                             }
                             // Merge with existing providers instead of overwriting
                             if (!this._providers.some(function (existing) { return existing.provider === injected_1; })) {
-                                this._providers = __spreadArray(__spreadArray([], this._providers, true), [this._injectedProviderDetail], false);
+                                this._providers = __spreadArray(__spreadArray([], this._providers, true), [
+                                    this._injectedProviderDetail,
+                                ], false);
                             }
                             return [2 /*return*/, this._providers];
                         }
@@ -1502,7 +1644,7 @@ var FormoAnalytics = /** @class */ (function () {
                         injectedProviderInfo = this.detectInjectedProviderInfo(injected_1);
                         injectedDetail = {
                             provider: injected_1,
-                            info: injectedProviderInfo
+                            info: injectedProviderInfo,
                         };
                         // Cache the detected injected provider detail
                         this._injectedProviderDetail = injectedDetail;
@@ -1841,9 +1983,10 @@ var FormoAnalytics = /** @class */ (function () {
      */
     FormoAnalytics.prototype.isProviderAlreadyWrapped = function (provider, currentRequest) {
         return !!(currentRequest &&
-            typeof currentRequest === 'function' &&
+            typeof currentRequest === "function" &&
             currentRequest[types_1.WRAPPED_REQUEST_SYMBOL] &&
-            provider[types_1.WRAPPED_REQUEST_REF_SYMBOL] === currentRequest);
+            provider[types_1.WRAPPED_REQUEST_REF_SYMBOL] ===
+                currentRequest);
     };
     /**
      * Handle provider mismatch by switching to the new provider and invalidating old tokens
@@ -1932,7 +2075,7 @@ var FormoAnalyticsSession = /** @class */ (function () {
         lib_1.logger.debug("Session: Checking wallet identification", {
             identifiedKey: identifiedKey,
             isIdentified: isIdentified,
-            hasRdns: !!rdns
+            hasRdns: !!rdns,
         });
         return isIdentified;
     };
@@ -1950,14 +2093,14 @@ var FormoAnalyticsSession = /** @class */ (function () {
             });
             lib_1.logger.debug("Session: Marked wallet as identified", {
                 identifiedKey: identifiedKey,
-                hasRdns: !!rdns
+                hasRdns: !!rdns,
             });
         }
         else {
             lib_1.logger.info("Session: Wallet already marked as identified", {
                 identifiedKey: identifiedKey,
                 existingWallets: identifiedWallets,
-                hasRdns: !!rdns
+                hasRdns: !!rdns,
             });
         }
     };