@formo/analytics 1.25.0 → 1.27.0

package/dist/cjs/src/FormoAnalyticsProvider.js

@@ -51,11 +51,13 @@ exports.useFormo = exports.FormoAnalyticsProvider = exports.FormoAnalyticsContex
 var jsx_runtime_1 = require("react/jsx-runtime");
 var react_1 = require("react");
 var FormoAnalytics_1 = require("./FormoAnalytics");
-var lib_1 = require("./lib");
+var storage_1 = require("./storage");
+var logger_1 = require("./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(); },
@@ -73,11 +75,11 @@ var FormoAnalyticsProvider = function (props) {
     var writeKey = props.writeKey, _a = props.disabled, disabled = _a === void 0 ? false : _a, children = props.children;
     // Keep the app running without analytics if no Write Key is provided or disabled
     if (!writeKey) {
-        lib_1.logger.error("FormoAnalyticsProvider: No Write Key provided");
+        logger_1.logger.error("FormoAnalyticsProvider: No Write Key provided");
         return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: children });
     }
     if (disabled) {
-        lib_1.logger.warn("FormoAnalytics is disabled");
+        logger_1.logger.warn("FormoAnalytics is disabled");
         return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: children });
     }
     return (0, jsx_runtime_1.jsx)(InitializedAnalytics, __assign({}, props));
@@ -86,42 +88,98 @@ exports.FormoAnalyticsProvider = FormoAnalyticsProvider;
 var InitializedAnalytics = function (_a) {
     var writeKey = _a.writeKey, options = _a.options, children = _a.children;
     var _b = (0, react_1.useState)(defaultContext), sdk = _b[0], setSdk = _b[1];
-    var initializedStartedRef = (0, react_1.useRef)(false);
-    (0, lib_1.initStorageManager)(writeKey);
+    var sdkRef = (0, react_1.useRef)(defaultContext);
+    (0, storage_1.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 = (0, react_1.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_1.logger.warn('Failed to serialize options, using timestamp', error);
+            return Date.now().toString();
+        }
+    }, [options]);
     (0, react_1.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_1.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_1.FormoAnalytics.init(writeKey, options)];
                     case 2:
                         sdkInstance = _a.sent();
-                        setSdk(sdkInstance);
-                        lib_1.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_1.logger.log("Successfully initialized FormoAnalytics SDK");
+                        }
+                        else {
+                            // Component was unmounted during initialization, clean up immediately
+                            logger_1.logger.log("Component unmounted during initialization, cleaning up SDK");
+                            sdkInstance.cleanup();
+                        }
                         return [3 /*break*/, 4];
                     case 3:
                         error_1 = _a.sent();
-                        lib_1.logger.error("Failed to initialize", error_1);
+                        if (!isCleanedUp) {
+                            logger_1.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_1.logger.log("Cleaning up FormoAnalytics SDK instance");
+                sdkRef.current.cleanup();
+                sdkRef.current = defaultContext;
+            }
+        };
+    }, [writeKey, optionsKey]);
     return ((0, jsx_runtime_1.jsx)(exports.FormoAnalyticsContext.Provider, { value: sdk, children: children }));
 };
 var useFormo = function () {
     var context = (0, react_1.useContext)(exports.FormoAnalyticsContext);
     if (!context) {
-        lib_1.logger.warn("useFormo called without a valid context");
+        logger_1.logger.warn("useFormo called without a valid context");
     }
     return context; // Return undefined if SDK is not initialized, handle accordingly in consumer
 };

package/dist/{esm/src/lib/consent.d.ts → cjs/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/cjs/src/{lib/consent.js → consent/index.js}

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

package/dist/cjs/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/cjs/src/constants/base.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BLOCKED_ADDRESSES = exports.DEAD_ADDRESS = exports.ZERO_ADDRESS = exports.DEFAULT_PROVIDER_ICON = exports.CONSENT_OPT_OUT_KEY = exports.LOCAL_ANONYMOUS_ID_KEY = exports.SESSION_USER_ID_KEY = exports.SESSION_CURRENT_URL_KEY = exports.SESSION_WALLET_IDENTIFIED_KEY = exports.SESSION_WALLET_DETECTED_KEY = exports.SESSION_TRAFFIC_SOURCE_KEY = void 0;
+exports.BLOCKED_ADDRESSES = exports.DEAD_ADDRESS = exports.ZERO_ADDRESS = exports.DEFAULT_PROVIDER_ICON = exports.CONSENT_OPT_OUT_KEY = exports.LOCAL_ANONYMOUS_ID_KEY = exports.SESSION_USER_ID_KEY = exports.SESSION_CURRENT_URL_KEY = exports.SESSION_TRAFFIC_SOURCE_KEY = void 0;
 exports.SESSION_TRAFFIC_SOURCE_KEY = "traffic-source";
-exports.SESSION_WALLET_DETECTED_KEY = "wallet-detected";
-exports.SESSION_WALLET_IDENTIFIED_KEY = "wallet-identified";
+// SESSION_WALLET_DETECTED_KEY and SESSION_WALLET_IDENTIFIED_KEY
+// are now defined in src/session/index.ts
 exports.SESSION_CURRENT_URL_KEY = "analytics-current-url";
 exports.SESSION_USER_ID_KEY = "user-id";
 exports.LOCAL_ANONYMOUS_ID_KEY = "anonymous-id";

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

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

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

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

@@ -51,15 +51,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventFactory = void 0;
-var constants_1 = require("../../constants");
-var utils_1 = require("../../utils");
-var address_1 = require("../../utils/address");
-var timestamp_1 = require("../../utils/timestamp");
-var validators_1 = require("../../validators");
+var constants_1 = require("../constants");
+var utils_1 = require("../utils");
+var address_1 = require("../utils/address");
+var timestamp_1 = require("../utils/timestamp");
+var validators_1 = require("../validators");
 var logger_1 = require("../logger");
 var mergeDeepRight_1 = __importDefault(require("../ramda/mergeDeepRight"));
 var storage_1 = require("../storage");
-var version_1 = require("../../version");
+var version_1 = require("../version");
 var constants_2 = require("./constants");
 var utils_2 = require("./utils");
 var browsers_1 = require("../browser/browsers");
@@ -409,12 +409,12 @@ var EventFactory = /** @class */ (function () {
             });
         });
     };
-    EventFactory.prototype.generateTransactionEvent = function (status, chainId, address, data, to, value, transactionHash, properties, context) {
+    EventFactory.prototype.generateTransactionEvent = function (status, chainId, address, data, to, value, transactionHash, function_name, function_args, properties, context) {
         return __awaiter(this, void 0, void 0, function () {
             var transactionEvent;
             return __generator(this, function (_a) {
                 transactionEvent = {
-                    properties: __assign(__assign({ status: status, chainId: chainId, data: data, to: to, value: value }, (transactionHash && { transactionHash: transactionHash })), properties),
+                    properties: __assign(__assign(__assign(__assign(__assign(__assign(__assign({ status: status, chainId: chainId }, (data && { data: data })), (to && { to: to })), (value && { value: value })), (transactionHash && { transactionHash: transactionHash })), (function_name && { function_name: function_name })), (function_args && { function_args: function_args })), properties),
                     address: address,
                     type: "transaction",
                 };
@@ -493,7 +493,7 @@ var EventFactory = /** @class */ (function () {
                     case 14:
                         formoEvent = _b.sent();
                         return [3 /*break*/, 19];
-                    case 15: return [4 /*yield*/, this.generateTransactionEvent(event.status, event.chainId, event.address, event.data, event.to, event.value, event.transactionHash, event.properties, event.context)];
+                    case 15: return [4 /*yield*/, this.generateTransactionEvent(event.status, event.chainId, event.address, event.data, event.to, event.value, event.transactionHash, event.function_name, event.function_args, event.properties, event.context)];
                     case 16:
                         formoEvent = _b.sent();
                         return [3 /*break*/, 19];

package/dist/cjs/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/cjs/src/{lib/event → event}/EventManager.js

@@ -50,7 +50,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventManager = void 0;
 var logger_1 = require("../logger");
 var EventFactory_1 = require("./EventFactory");
-var address_1 = require("../../utils/address");
+var address_1 = require("../utils/address");
 /**
  * A service to generate valid event payloads and queue them for processing
  */

package/dist/cjs/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/cjs/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/cjs/src/{lib/event → event}/utils.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateAnonymousId = void 0;
 exports.getCookieDomain = getCookieDomain;
-var utils_1 = require("../../utils");
+var utils_1 = require("../utils");
 var storage_1 = require("../storage");
 var generateAnonymousId = function (key) {
     var storedAnonymousId = (0, storage_1.cookie)().get(key);

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

@@ -0,0 +1,11 @@
+export interface FetchRetryError extends Error {
+    response?: Response;
+}
+type RetryOptions = {
+    retries?: number;
+    retryDelay?: (attempt: number) => number;
+    retryOn?: (attempt: number, error: FetchRetryError | null, response: Response | null) => boolean;
+};
+declare function fetchWithRetry(input: RequestInfo | URL, init?: RequestInit & RetryOptions): Promise<Response>;
+export default fetchWithRetry;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,126 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function fetchWithRetry(input, init) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, _b, retries, retryDelay, retryOn, fetchInit, _loop_1, attempt, state_1;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _a = init || {}, _b = _a.retries, retries = _b === void 0 ? 0 : _b, retryDelay = _a.retryDelay, retryOn = _a.retryOn, fetchInit = __rest(_a, ["retries", "retryDelay", "retryOn"]);
+                    _loop_1 = function (attempt) {
+                        var isLastAttempt, response, responseError, error_1;
+                        return __generator(this, function (_d) {
+                            switch (_d.label) {
+                                case 0:
+                                    isLastAttempt = attempt === retries;
+                                    _d.label = 1;
+                                case 1:
+                                    _d.trys.push([1, 6, , 10]);
+                                    return [4 /*yield*/, globalThis.fetch(input, fetchInit)];
+                                case 2:
+                                    response = _d.sent();
+                                    if (response.ok) {
+                                        return [2 /*return*/, { value: response }];
+                                    }
+                                    // On the last attempt, return whatever we got
+                                    if (isLastAttempt) {
+                                        return [2 /*return*/, { value: response }];
+                                    }
+                                    responseError = new Error(response.statusText);
+                                    responseError.response = response;
+                                    if (!(retryOn === null || retryOn === void 0 ? void 0 : retryOn(attempt, responseError, response))) return [3 /*break*/, 5];
+                                    if (!retryDelay) return [3 /*break*/, 4];
+                                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, retryDelay(attempt)); })];
+                                case 3:
+                                    _d.sent();
+                                    _d.label = 4;
+                                case 4: return [2 /*return*/, "continue"];
+                                case 5: return [2 /*return*/, { value: response }];
+                                case 6:
+                                    error_1 = _d.sent();
+                                    // On the last attempt, throw immediately
+                                    if (isLastAttempt) {
+                                        throw error_1;
+                                    }
+                                    if (!(retryOn === null || retryOn === void 0 ? void 0 : retryOn(attempt, error_1, null))) return [3 /*break*/, 9];
+                                    if (!retryDelay) return [3 /*break*/, 8];
+                                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, retryDelay(attempt)); })];
+                                case 7:
+                                    _d.sent();
+                                    _d.label = 8;
+                                case 8: return [2 /*return*/, "continue"];
+                                case 9: throw error_1;
+                                case 10: return [2 /*return*/];
+                            }
+                        });
+                    };
+                    attempt = 0;
+                    _c.label = 1;
+                case 1:
+                    if (!(attempt <= retries)) return [3 /*break*/, 4];
+                    return [5 /*yield**/, _loop_1(attempt)];
+                case 2:
+                    state_1 = _c.sent();
+                    if (typeof state_1 === "object")
+                        return [2 /*return*/, state_1.value];
+                    _c.label = 3;
+                case 3:
+                    attempt++;
+                    return [3 /*break*/, 1];
+                case 4: 
+                // Unreachable — the loop always returns or throws on the last attempt.
+                // Required to satisfy TypeScript's control flow analysis.
+                throw new Error("Unexpected: retry loop exited without returning or throwing");
+            }
+        });
+    });
+}
+exports.default = fetchWithRetry;
+//# sourceMappingURL=index.js.map

package/dist/cjs/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

package/dist/cjs/src/provider/detection.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Provider detection utilities for identifying wallet providers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROVIDER_ICON = void 0;
+exports.detectInjectedProviderInfo = detectInjectedProviderInfo;
+exports.isValidProvider = isValidProvider;
+/**
+ * Default icon for providers without custom icons
+ */
+exports.DEFAULT_PROVIDER_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCAzMiAzMiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjMyIiBoZWlnaHQ9IjMyIiBmaWxsPSIjRkZGIi8+CjxwYXRoIGQ9Ik0xNiA4TDggMjRoMTZMMTYgOHoiIGZpbGw9IiMzMzMiLz4KPC9zdmc+Cg==";
+/**
+ * Known wallet providers with their identifying flags and metadata
+ */
+var KNOWN_PROVIDERS = [
+    {
+        flag: 'isMetaMask',
+        name: 'MetaMask',
+        rdns: 'io.metamask',
+    },
+    {
+        flag: 'isCoinbaseWallet',
+        name: 'Coinbase Wallet',
+        rdns: 'com.coinbase.wallet',
+    },
+    {
+        flag: 'isWalletConnect',
+        name: 'WalletConnect',
+        rdns: 'com.walletconnect',
+    },
+    {
+        flag: 'isTrust',
+        name: 'Trust Wallet',
+        rdns: 'com.trustwallet',
+    },
+    {
+        flag: 'isBraveWallet',
+        name: 'Brave Wallet',
+        rdns: 'com.brave.wallet',
+    },
+    {
+        flag: 'isPhantom',
+        name: 'Phantom',
+        rdns: 'app.phantom',
+    },
+];
+/**
+ * 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"
+ * ```
+ */
+function detectInjectedProviderInfo(provider) {
+    // Default values for unknown providers
+    var name = "Injected Provider";
+    var rdns = "io.injected.provider";
+    // Cast to check for wallet-specific flags
+    var flags = provider;
+    // Check known providers in order of precedence
+    for (var _i = 0, KNOWN_PROVIDERS_1 = KNOWN_PROVIDERS; _i < KNOWN_PROVIDERS_1.length; _i++) {
+        var knownProvider = KNOWN_PROVIDERS_1[_i];
+        if (flags[knownProvider.flag]) {
+            name = knownProvider.name;
+            rdns = knownProvider.rdns;
+            break;
+        }
+    }
+    return {
+        name: name,
+        rdns: rdns,
+        uuid: "injected-".concat(rdns.replace(/[^a-zA-Z0-9]/g, "-")),
+        icon: exports.DEFAULT_PROVIDER_ICON,
+    };
+}
+/**
+ * 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
+ * }
+ * ```
+ */
+function isValidProvider(provider) {
+    return (!!provider &&
+        typeof provider.request === "function" &&
+        typeof provider.on === "function" &&
+        typeof provider.removeListener === "function");
+}
+//# sourceMappingURL=detection.js.map

package/dist/cjs/src/provider/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Provider-related exports
+ */
+export { detectInjectedProviderInfo, isValidProvider, DEFAULT_PROVIDER_ICON, } from './detection';
+export type { WalletProviderFlags, ProviderInfo, } from './detection';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/src/provider/index.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Provider-related exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROVIDER_ICON = exports.isValidProvider = exports.detectInjectedProviderInfo = void 0;
+var detection_1 = require("./detection");
+Object.defineProperty(exports, "detectInjectedProviderInfo", { enumerable: true, get: function () { return detection_1.detectInjectedProviderInfo; } });
+Object.defineProperty(exports, "isValidProvider", { enumerable: true, get: function () { return detection_1.isValidProvider; } });
+Object.defineProperty(exports, "DEFAULT_PROVIDER_ICON", { enumerable: true, get: function () { return detection_1.DEFAULT_PROVIDER_ICON; } });
+//# sourceMappingURL=index.js.map