@formo/analytics 1.25.0 → 1.26.0

package/dist/esm/src/FormoAnalytics.js

@@ -55,13 +55,20 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { createStore } from "mipd";
-import { EVENTS_API_HOST, EventType, LOCAL_ANONYMOUS_ID_KEY, SESSION_CURRENT_URL_KEY, SESSION_USER_ID_KEY, SESSION_WALLET_DETECTED_KEY, SESSION_WALLET_IDENTIFIED_KEY, DEFAULT_PROVIDER_ICON, CONSENT_OPT_OUT_KEY, } from "./constants";
-import { cookie, EventManager, EventQueue, initStorageManager, logger, Logger, setConsentFlag, getConsentFlag, removeConsentFlag, } from "./lib";
+import { EVENTS_API_HOST, EventType, LOCAL_ANONYMOUS_ID_KEY, SESSION_CURRENT_URL_KEY, SESSION_USER_ID_KEY, CONSENT_OPT_OUT_KEY, } from "./constants";
+import { cookie, initStorageManager } from "./storage";
+import { EventManager } from "./event";
+import { EventQueue } from "./queue";
+import { logger, Logger } from "./logger";
+import { setConsentFlag, getConsentFlag, removeConsentFlag, } from "./consent";
+import { detectInjectedProviderInfo, isValidProvider } from "./provider";
+import { FormoAnalyticsSession, SESSION_WALLET_DETECTED_KEY, SESSION_WALLET_IDENTIFIED_KEY, } from "./session";
 import { SignatureStatus, TransactionStatus, WRAPPED_REQUEST_SYMBOL, WRAPPED_REQUEST_REF_SYMBOL, } from "./types";
 import { toChecksumAddress } from "./utils";
 import { getValidAddress } from "./utils/address";
 import { isLocalhost } from "./validators";
 import { parseChainId } from "./utils/chain";
+import { WagmiEventHandler } from "./wagmi";
 /**
  * Constants for provider switching reasons
  */
@@ -95,11 +102,18 @@ var FormoAnalytics = /** @class */ (function () {
         this._processingAccountsChanged = false;
         // Set to efficiently track seen providers for deduplication and O(1) lookup
         this._seenProviders = new Set();
+        /**
+         * Flag indicating if Wagmi mode is enabled
+         * When true, EIP-1193 provider wrapping is skipped
+         */
+        this.isWagmiMode = false;
         this.currentUserId = "";
         this.config = {
             writeKey: writeKey,
         };
         this.options = options;
+        // Check if Wagmi mode is enabled
+        this.isWagmiMode = !!options.wagmi;
         this.session = new FormoAnalyticsSession();
         this.currentUserId =
             cookie().get(SESSION_USER_ID_KEY) || undefined;
@@ -128,17 +142,24 @@ var FormoAnalytics = /** @class */ (function () {
         if (this.hasOptedOutTracking()) {
             logger.info("User has previously opted out of tracking");
         }
-        // Handle initial provider (injected) as fallback; listeners for EIP-6963 are added later
-        var provider = undefined;
-        var optProvider = options.provider;
-        if (optProvider) {
-            provider = optProvider;
+        // Initialize Wagmi handler if Wagmi mode is enabled
+        if (this.isWagmiMode && options.wagmi) {
+            logger.info("FormoAnalytics: Initializing in Wagmi mode");
+            this.wagmiHandler = new WagmiEventHandler(this, options.wagmi.config, options.wagmi.queryClient);
         }
-        else if (typeof window !== "undefined" && window.ethereum) {
-            provider = window.ethereum;
-        }
-        if (provider) {
-            this.trackProvider(provider);
+        else {
+            // Handle initial provider (injected) as fallback; listeners for EIP-6963 are added later
+            var provider = undefined;
+            var optProvider = options.provider;
+            if (optProvider) {
+                provider = optProvider;
+            }
+            else if (typeof window !== "undefined" && window.ethereum) {
+                provider = window.ethereum;
+            }
+            if (provider) {
+                this.trackEIP1193Provider(provider);
+            }
         }
         this.trackPageHit();
         this.trackPageHits();
@@ -153,18 +174,6 @@ var FormoAnalytics = /** @class */ (function () {
         // This allows legitimate provider switching while preventing race conditions
         return this._provider != null && this._provider !== provider;
     };
-    /**
-     * Check if a provider is in a valid state for switching
-     * @param provider The provider to validate
-     * @returns true if the provider is in a valid state
-     */
-    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");
-    };
     FormoAnalytics.init = function (writeKey, options) {
         return __awaiter(this, void 0, void 0, function () {
             var analytics, _a;
@@ -173,6 +182,7 @@ var FormoAnalytics = /** @class */ (function () {
                     case 0:
                         initStorageManager(writeKey);
                         analytics = new FormoAnalytics(writeKey, options);
+                        if (!!analytics.isWagmiMode) return [3 /*break*/, 3];
                         // Auto-detect wallet provider
                         _a = analytics;
                         return [4 /*yield*/, analytics.getProviders()];
@@ -183,7 +193,11 @@ var FormoAnalytics = /** @class */ (function () {
                     case 2:
                         _b.sent();
                         analytics.trackProviders(analytics._providers);
-                        return [2 /*return*/, analytics];
+                        return [3 /*break*/, 4];
+                    case 3:
+                        logger.info("FormoAnalytics: Skipping provider detection (Wagmi mode)");
+                        _b.label = 4;
+                    case 4: return [2 /*return*/, analytics];
                 }
             });
         });
@@ -223,6 +237,27 @@ var FormoAnalytics = /** @class */ (function () {
         cookie().remove(SESSION_WALLET_DETECTED_KEY);
         cookie().remove(SESSION_WALLET_IDENTIFIED_KEY);
     };
+    /**
+     * Clean up resources and event listeners
+     * Call this when destroying the analytics instance
+     * @returns {void}
+     */
+    FormoAnalytics.prototype.cleanup = function () {
+        logger.info("FormoAnalytics: Cleaning up resources");
+        // Clean up Wagmi handler if present
+        if (this.wagmiHandler) {
+            this.wagmiHandler.cleanup();
+            this.wagmiHandler = undefined;
+        }
+        // Clean up EIP-1193 providers if not in Wagmi mode
+        if (!this.isWagmiMode) {
+            for (var _i = 0, _a = Array.from(this._trackedProviders); _i < _a.length; _i++) {
+                var provider = _a[_i];
+                this.untrackProvider(provider);
+            }
+        }
+        logger.info("FormoAnalytics: Cleanup complete");
+    };
     /**
      * Emits a connect wallet event.
      * @param {ChainID} params.chainId
@@ -612,13 +647,29 @@ var FormoAnalytics = /** @class */ (function () {
     /*
       SDK tracking and event listener functions
     */
-    FormoAnalytics.prototype.trackProvider = function (provider) {
-        logger.info("trackProvider", provider);
+    /**
+     * Track an EIP-1193 provider by wrapping its request method and adding event listeners
+     * Note: This is only used in non-Wagmi mode. When Wagmi is enabled, all tracking
+     * happens through Wagmi's connector system instead of EIP-1193/EIP-6963.
+     * @param provider The EIP-1193 provider to track
+     */
+    FormoAnalytics.prototype.trackEIP1193Provider = function (provider) {
+        logger.info("trackEIP1193Provider", provider);
+        // Defensive check: Skip provider tracking in Wagmi mode
+        // This should never be called in Wagmi mode due to guards in init(),
+        // but we check here for safety in case of future code changes
+        if (this.isWagmiMode) {
+            logger.debug("trackEIP1193Provider: Skipping EIP-1193 provider tracking (Wagmi mode - using connector system instead)");
+            return;
+        }
         try {
-            if (!provider)
+            // Validate provider exists and has required methods
+            if (!isValidProvider(provider)) {
+                logger.warn("trackEIP1193Provider: Invalid provider - missing required methods");
                 return;
+            }
             if (this._trackedProviders.has(provider)) {
-                logger.warn("TrackProvider: Provider already tracked.");
+                logger.warn("trackEIP1193Provider: Provider already tracked");
                 return;
             }
             // CRITICAL: Always register accountsChanged for state management
@@ -654,7 +705,7 @@ var FormoAnalytics = /** @class */ (function () {
                 var eip6963ProviderDetail = providers_1[_i];
                 var provider = eip6963ProviderDetail === null || eip6963ProviderDetail === void 0 ? void 0 : eip6963ProviderDetail.provider;
                 if (provider && !this._trackedProviders.has(provider)) {
-                    this.trackProvider(provider);
+                    this.trackEIP1193Provider(provider);
                 }
             }
         }
@@ -1512,60 +1563,12 @@ var FormoAnalytics = /** @class */ (function () {
             };
         }
         // Fallback to injected provider detection
-        var injectedInfo = this.detectInjectedProviderInfo(provider);
+        var injectedInfo = detectInjectedProviderInfo(provider);
         return {
             name: injectedInfo.name,
             rdns: injectedInfo.rdns,
         };
     };
-    /**
-     * Attempts to detect information about an injected provider
-     * @param provider The injected provider to analyze
-     * @returns Provider information with fallback values
-     */
-    FormoAnalytics.prototype.detectInjectedProviderInfo = function (provider) {
-        // Try to detect provider type from common properties
-        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";
-        }
-        // Check if it's Coinbase Wallet
-        else if (flags.isCoinbaseWallet) {
-            name = "Coinbase Wallet";
-            rdns = "com.coinbase.wallet";
-        }
-        // Check if it's WalletConnect
-        else if (flags.isWalletConnect) {
-            name = "WalletConnect";
-            rdns = "com.walletconnect";
-        }
-        // Check if it's Trust Wallet
-        else if (flags.isTrust) {
-            name = "Trust Wallet";
-            rdns = "com.trustwallet";
-        }
-        // Check if it's Brave Wallet
-        else if (flags.isBraveWallet) {
-            name = "Brave Wallet";
-            rdns = "com.brave.wallet";
-        }
-        // Check if it's Phantom
-        else if (flags.isPhantom) {
-            name = "Phantom";
-            rdns = "app.phantom";
-        }
-        return {
-            name: name,
-            rdns: rdns,
-            uuid: "injected-".concat(rdns.replace(/[^a-zA-Z0-9]/g, "-")),
-            icon: DEFAULT_PROVIDER_ICON,
-        };
-    };
     FormoAnalytics.prototype.getProviders = function () {
         return __awaiter(this, void 0, void 0, function () {
             var store, providers, injected_1, injectedProviderInfo, injectedDetail, uniqueProviders, _i, uniqueProviders_1, detail;
@@ -1624,7 +1627,7 @@ var FormoAnalytics = /** @class */ (function () {
                             this._injectedProviderDetail.provider === injected_1) {
                             // Ensure it's tracked
                             if (!this._trackedProviders.has(injected_1)) {
-                                this.trackProvider(injected_1);
+                                this.trackEIP1193Provider(injected_1);
                             }
                             // Merge with existing providers instead of overwriting
                             if (!this._providers.some(function (existing) { return existing.provider === injected_1; })) {
@@ -1636,9 +1639,9 @@ var FormoAnalytics = /** @class */ (function () {
                         }
                         // Re-check if the injected provider is already tracked just before tracking
                         if (!this._trackedProviders.has(injected_1)) {
-                            this.trackProvider(injected_1);
+                            this.trackEIP1193Provider(injected_1);
                         }
-                        injectedProviderInfo = this.detectInjectedProviderInfo(injected_1);
+                        injectedProviderInfo = detectInjectedProviderInfo(injected_1);
                         injectedDetail = {
                             provider: injected_1,
                             info: injectedProviderInfo,
@@ -2040,67 +2043,4 @@ var FormoAnalytics = /** @class */ (function () {
     return FormoAnalytics;
 }());
 export { FormoAnalytics };
-var FormoAnalyticsSession = /** @class */ (function () {
-    function FormoAnalyticsSession() {
-    }
-    FormoAnalyticsSession.prototype.generateIdentificationKey = function (address, rdns) {
-        // If rdns is missing, use address-only key as fallback for empty identifies
-        return rdns ? "".concat(address, ":").concat(rdns) : address;
-    };
-    FormoAnalyticsSession.prototype.isWalletDetected = function (rdns) {
-        var _a;
-        var rdnses = ((_a = cookie().get(SESSION_WALLET_DETECTED_KEY)) === null || _a === void 0 ? void 0 : _a.split(",")) || [];
-        return rdnses.includes(rdns);
-    };
-    FormoAnalyticsSession.prototype.markWalletDetected = function (rdns) {
-        var _a;
-        var rdnses = ((_a = cookie().get(SESSION_WALLET_DETECTED_KEY)) === null || _a === void 0 ? void 0 : _a.split(",")) || [];
-        if (!rdnses.includes(rdns)) {
-            rdnses.push(rdns);
-            cookie().set(SESSION_WALLET_DETECTED_KEY, rdnses.join(","), {
-                // by the end of the day
-                expires: new Date(Date.now() + 86400 * 1000).toUTCString(),
-                path: "/",
-            });
-        }
-    };
-    FormoAnalyticsSession.prototype.isWalletIdentified = function (address, rdns) {
-        var identifiedKey = this.generateIdentificationKey(address, rdns);
-        var cookieValue = cookie().get(SESSION_WALLET_IDENTIFIED_KEY);
-        var identifiedWallets = (cookieValue === null || cookieValue === void 0 ? void 0 : cookieValue.split(",")) || [];
-        var isIdentified = identifiedWallets.includes(identifiedKey);
-        logger.debug("Session: Checking wallet identification", {
-            identifiedKey: identifiedKey,
-            isIdentified: isIdentified,
-            hasRdns: !!rdns,
-        });
-        return isIdentified;
-    };
-    FormoAnalyticsSession.prototype.markWalletIdentified = function (address, rdns) {
-        var _a;
-        var identifiedKey = this.generateIdentificationKey(address, rdns);
-        var identifiedWallets = ((_a = cookie().get(SESSION_WALLET_IDENTIFIED_KEY)) === null || _a === void 0 ? void 0 : _a.split(",")) || [];
-        if (!identifiedWallets.includes(identifiedKey)) {
-            identifiedWallets.push(identifiedKey);
-            var newValue = identifiedWallets.join(",");
-            cookie().set(SESSION_WALLET_IDENTIFIED_KEY, newValue, {
-                // by the end of the day
-                expires: new Date(Date.now() + 86400 * 1000).toUTCString(),
-                path: "/",
-            });
-            logger.debug("Session: Marked wallet as identified", {
-                identifiedKey: identifiedKey,
-                hasRdns: !!rdns,
-            });
-        }
-        else {
-            logger.info("Session: Wallet already marked as identified", {
-                identifiedKey: identifiedKey,
-                existingWallets: identifiedWallets,
-                hasRdns: !!rdns,
-            });
-        }
-    };
-    return FormoAnalyticsSession;
-}());
 //# sourceMappingURL=FormoAnalytics.js.map

package/dist/esm/src/FormoAnalyticsProvider.js

@@ -46,13 +46,15 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useEffect, useRef, useState } from "react";
+import { createContext, useContext, useEffect, useMemo, useRef, useState } from "react";
 import { FormoAnalytics } from "./FormoAnalytics";
-import { initStorageManager, logger } from "./lib";
+import { initStorageManager } from "./storage";
+import { logger } from "./logger";
 var defaultContext = {
     chain: function () { return Promise.resolve(); },
     page: function () { return Promise.resolve(); },
     reset: function () { },
+    cleanup: function () { },
     detect: function () { return Promise.resolve(); },
     connect: function () { return Promise.resolve(); },
     disconnect: function () { return Promise.resolve(); },
@@ -82,36 +84,92 @@ export var FormoAnalyticsProvider = function (props) {
 var InitializedAnalytics = function (_a) {
     var writeKey = _a.writeKey, options = _a.options, children = _a.children;
     var _b = useState(defaultContext), sdk = _b[0], setSdk = _b[1];
-    var initializedStartedRef = useRef(false);
+    var sdkRef = useRef(defaultContext);
     initStorageManager(writeKey);
+    // Create a stable key from options that ignores complex objects and functions
+    // We only care about serializable config values that would affect SDK behavior
+    var optionsKey = useMemo(function () {
+        if (!options)
+            return 'undefined';
+        // Extract only the serializable parts of options
+        var serializableOptions = {
+            tracking: options.tracking,
+            autocapture: options.autocapture,
+            apiHost: options.apiHost,
+            flushAt: options.flushAt,
+            flushInterval: options.flushInterval,
+            retryCount: options.retryCount,
+            maxQueueSize: options.maxQueueSize,
+            logger: options.logger,
+            referral: options.referral,
+            // For complex objects, just track their presence, not their content
+            hasProvider: !!options.provider,
+            hasWagmi: !!options.wagmi,
+            hasReady: !!options.ready,
+        };
+        try {
+            return JSON.stringify(serializableOptions);
+        }
+        catch (error) {
+            // Fallback to timestamp if serialization fails
+            logger.warn('Failed to serialize options, using timestamp', error);
+            return Date.now().toString();
+        }
+    }, [options]);
     useEffect(function () {
+        var isCleanedUp = false;
         var initialize = function () { return __awaiter(void 0, void 0, void 0, function () {
             var sdkInstance, error_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (initializedStartedRef.current)
-                            return [2 /*return*/];
-                        initializedStartedRef.current = true;
+                        // Clean up existing SDK instance before creating a new one
+                        if (sdkRef.current && sdkRef.current !== defaultContext) {
+                            logger.log("Cleaning up existing FormoAnalytics SDK instance before re-initialization");
+                            sdkRef.current.cleanup();
+                            sdkRef.current = defaultContext;
+                            setSdk(defaultContext);
+                        }
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 3, , 4]);
                         return [4 /*yield*/, FormoAnalytics.init(writeKey, options)];
                     case 2:
                         sdkInstance = _a.sent();
-                        setSdk(sdkInstance);
-                        logger.log("Successfully initialized");
+                        // Only set SDK if the component hasn't been cleaned up during async initialization
+                        if (!isCleanedUp) {
+                            setSdk(sdkInstance);
+                            sdkRef.current = sdkInstance;
+                            logger.log("Successfully initialized FormoAnalytics SDK");
+                        }
+                        else {
+                            // Component was unmounted during initialization, clean up immediately
+                            logger.log("Component unmounted during initialization, cleaning up SDK");
+                            sdkInstance.cleanup();
+                        }
                         return [3 /*break*/, 4];
                     case 3:
                         error_1 = _a.sent();
-                        logger.error("Failed to initialize", error_1);
+                        if (!isCleanedUp) {
+                            logger.error("Failed to initialize FormoAnalytics SDK", error_1);
+                        }
                         return [3 /*break*/, 4];
                     case 4: return [2 /*return*/];
                 }
             });
         }); };
         initialize();
-    }, [writeKey, options]);
+        // Cleanup function to prevent memory leaks
+        // Using ref ensures we clean up the actual SDK instance, not the stale closure value
+        return function () {
+            isCleanedUp = true;
+            if (sdkRef.current && sdkRef.current !== defaultContext) {
+                logger.log("Cleaning up FormoAnalytics SDK instance");
+                sdkRef.current.cleanup();
+                sdkRef.current = defaultContext;
+            }
+        };
+    }, [writeKey, optionsKey]);
     return (_jsx(FormoAnalyticsContext.Provider, { value: sdk, children: children }));
 };
 export var useFormo = function () {

package/dist/{cjs/src/lib/consent.d.ts → esm/src/consent/index.d.ts}

@@ -32,4 +32,4 @@ export declare function getConsentFlag(projectId: string, key: string): string |
  * @param key - The cookie key
  */
 export declare function removeConsentFlag(projectId: string, key: string): void;
-//# sourceMappingURL=consent.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/src/{lib/consent.js → consent/index.js}

@@ -94,4 +94,4 @@ function deleteCookieDirectly(cookieName) {
         }
     }
 }
-//# sourceMappingURL=consent.js.map
+//# sourceMappingURL=index.js.map

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

@@ -1,6 +1,4 @@
 export declare const SESSION_TRAFFIC_SOURCE_KEY = "traffic-source";
-export declare const SESSION_WALLET_DETECTED_KEY = "wallet-detected";
-export declare const SESSION_WALLET_IDENTIFIED_KEY = "wallet-identified";
 export declare const SESSION_CURRENT_URL_KEY = "analytics-current-url";
 export declare const SESSION_USER_ID_KEY = "user-id";
 export declare const LOCAL_ANONYMOUS_ID_KEY = "anonymous-id";

package/dist/esm/src/constants/base.js

@@ -1,6 +1,6 @@
 export var SESSION_TRAFFIC_SOURCE_KEY = "traffic-source";
-export var SESSION_WALLET_DETECTED_KEY = "wallet-detected";
-export var SESSION_WALLET_IDENTIFIED_KEY = "wallet-identified";
+// SESSION_WALLET_DETECTED_KEY and SESSION_WALLET_IDENTIFIED_KEY
+// are now defined in src/session/index.ts
 export var SESSION_CURRENT_URL_KEY = "analytics-current-url";
 export var SESSION_USER_ID_KEY = "user-id";
 export var LOCAL_ANONYMOUS_ID_KEY = "anonymous-id";

package/dist/esm/src/constants/config.js

@@ -2,7 +2,7 @@ export var EVENTS_API_ORIGIN = "https://events.formo.so";
 export var EVENTS_API_HOST = "".concat(EVENTS_API_ORIGIN, "/v0/raw_events");
 export var EVENTS_API_REQUEST_HEADER = function (writeKey) { return ({
     "Content-Type": "application/json",
-    Authorization: "Basic ".concat(writeKey),
+    Authorization: "Bearer ".concat(writeKey),
 }); };
 export var COUNTRY_LIST = {
     // Africa

package/dist/esm/src/{lib/event → event}/EventFactory.d.ts

@@ -1,4 +1,4 @@
-import { Address, APIEvent, ChainID, IFormoEvent, IFormoEventContext, IFormoEventProperties, Nullable, Options, SignatureStatus, TransactionStatus } from "../../types";
+import { Address, APIEvent, ChainID, IFormoEvent, IFormoEventContext, IFormoEventProperties, Nullable, Options, SignatureStatus, TransactionStatus } from "../types";
 import { IEventFactory } from "./type";
 declare class EventFactory implements IEventFactory {
     private options?;

package/dist/esm/src/{lib/event → event}/EventFactory.js

@@ -45,15 +45,15 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-import { COUNTRY_LIST, LOCAL_ANONYMOUS_ID_KEY, SESSION_TRAFFIC_SOURCE_KEY, } from "../../constants";
-import { toChecksumAddress, toSnakeCase } from "../../utils";
-import { getValidAddress } from "../../utils/address";
-import { getCurrentTimeFormatted } from "../../utils/timestamp";
-import { isUndefined } from "../../validators";
+import { COUNTRY_LIST, LOCAL_ANONYMOUS_ID_KEY, SESSION_TRAFFIC_SOURCE_KEY, } from "../constants";
+import { toChecksumAddress, toSnakeCase } from "../utils";
+import { getValidAddress } from "../utils/address";
+import { getCurrentTimeFormatted } from "../utils/timestamp";
+import { isUndefined } from "../validators";
 import { logger } from "../logger";
 import mergeDeepRight from "../ramda/mergeDeepRight";
 import { session } from "../storage";
-import { version } from "../../version";
+import { version } from "../version";
 import { CHANNEL, VERSION, PAGE_PROPERTIES_EXCLUDED_FIELDS } from "./constants";
 import { generateAnonymousId } from "./utils";
 import { detectBrowser } from "../browser/browsers";

package/dist/esm/src/{lib/event → event}/EventManager.d.ts

@@ -1,4 +1,4 @@
-import { Address, APIEvent, Options } from "../../types";
+import { Address, APIEvent, Options } from "../types";
 import { IEventQueue } from "../queue";
 import { IEventFactory, IEventManager } from "./type";
 /**

package/dist/esm/src/{lib/event → event}/EventManager.js

@@ -47,7 +47,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 import { logger } from "../logger";
 import { EventFactory } from "./EventFactory";
-import { isBlockedAddress } from "../../utils/address";
+import { isBlockedAddress } from "../utils/address";
 /**
  * A service to generate valid event payloads and queue them for processing
  */

package/dist/esm/src/{lib/event → event}/type.d.ts

@@ -1,4 +1,4 @@
-import { Address, APIEvent, IFormoEvent } from "../../types";
+import { Address, APIEvent, IFormoEvent } from "../types";
 export interface IEventManager {
     addEvent(event: APIEvent, address?: Address, userId?: string): Promise<void>;
 }

package/dist/esm/src/{lib/event → event}/utils.d.ts

@@ -1,4 +1,4 @@
-import { AnonymousID } from "../../types";
+import { AnonymousID } from "../types";
 declare const generateAnonymousId: (key: string) => AnonymousID;
 declare function getCookieDomain(hostname?: string): string;
 export { generateAnonymousId, getCookieDomain };

package/dist/esm/src/{lib/event → event}/utils.js

@@ -1,4 +1,4 @@
-import { generateNativeUUID } from "../../utils";
+import { generateNativeUUID } from "../utils";
 import { cookie } from "../storage";
 var generateAnonymousId = function (key) {
     var storedAnonymousId = cookie().get(key);

package/dist/esm/src/{lib/fetch.d.ts → fetch/index.d.ts}

@@ -1,3 +1,3 @@
 declare const _default: (input: string | URL | Request, init?: (RequestInit & import("fetch-retry").RequestInitRetryParams<typeof globalThis.fetch>) | undefined) => Promise<Response>;
 export default _default;
-//# sourceMappingURL=fetch.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/src/{lib/fetch.js → fetch/index.js}

@@ -1,3 +1,3 @@
 import fetch from "fetch-retry";
 export default fetch(global.fetch);
-//# sourceMappingURL=fetch.js.map
+//# sourceMappingURL=index.js.map

package/dist/esm/src/provider/detection.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Provider detection utilities for identifying wallet providers
+ */
+import { EIP1193Provider } from "../types";
+/**
+ * Default icon for providers without custom icons
+ */
+export declare const DEFAULT_PROVIDER_ICON: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCAzMiAzMiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjMyIiBoZWlnaHQ9IjMyIiBmaWxsPSIjRkZGIi8+CjxwYXRoIGQ9Ik0xNiA4TDggMjRoMTZMMTYgOHoiIGZpbGw9IiMzMzMiLz4KPC9zdmc+Cg==";
+/**
+ * Common wallet provider flags used for detection
+ */
+export interface WalletProviderFlags {
+    isMetaMask?: boolean;
+    isCoinbaseWallet?: boolean;
+    isWalletConnect?: boolean;
+    isTrust?: boolean;
+    isBraveWallet?: boolean;
+    isPhantom?: boolean;
+}
+/**
+ * Provider information returned by detection
+ */
+export interface ProviderInfo {
+    name: string;
+    rdns: string;
+    uuid: string;
+    icon: `data:image/${string}`;
+}
+/**
+ * Attempts to detect information about an injected provider by examining
+ * common wallet-specific flags and properties.
+ *
+ * @param provider The injected provider to analyze
+ * @returns Provider information with fallback values if detection fails
+ *
+ * @example
+ * ```typescript
+ * const provider = window.ethereum;
+ * const info = detectInjectedProviderInfo(provider);
+ * console.log(info.name); // "MetaMask" or "Injected Provider"
+ * ```
+ */
+export declare function detectInjectedProviderInfo(provider: EIP1193Provider): ProviderInfo;
+/**
+ * Validates that a provider implements the required EIP-1193 interface
+ *
+ * @param provider The provider to validate
+ * @returns true if the provider has all required methods
+ *
+ * @example
+ * ```typescript
+ * if (isValidProvider(window.ethereum)) {
+ *   // Safe to use provider
+ * }
+ * ```
+ */
+export declare function isValidProvider(provider: EIP1193Provider | undefined | null): provider is EIP1193Provider;
+//# sourceMappingURL=detection.d.ts.map