@formo/analytics 1.13.4-alpha.1 → 1.13.4-alpha.10

package/dist/esm/src/FormoAnalytics.js

@@ -0,0 +1,947 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import axios from "axios";
+import { createStore } from "mipd";
+import { COUNTRY_LIST, CURRENT_URL_KEY, EVENTS_API_URL, Event, } from "./constants";
+import { SignatureStatus, TransactionStatus, } from "./types";
+import { session, isLocalhost, toSnakeCase } from "./lib";
+import { SESSION_IDENTIFIED_KEY } from "./constants";
+var FormoAnalytics = /** @class */ (function () {
+    function FormoAnalytics(apiKey, options) {
+        if (options === void 0) { options = {}; }
+        this.apiKey = apiKey;
+        this.options = options;
+        this._providerListeners = {};
+        this.config = {
+            apiKey: apiKey,
+            trackLocalhost: options.trackLocalhost,
+        };
+        this.session = new FormoAnalyticsSession();
+        // TODO: replace with eip6963
+        var provider = options.provider || (window === null || window === void 0 ? void 0 : window.ethereum);
+        if (provider) {
+            this.trackProvider(provider);
+        }
+        this.trackFirstPageHit();
+        this.trackPageHits();
+    }
+    FormoAnalytics.init = function (apiKey, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var analytics, providers;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        analytics = new FormoAnalytics(apiKey, options);
+                        return [4 /*yield*/, analytics.getProviders()];
+                    case 1:
+                        providers = _a.sent();
+                        return [4 /*yield*/, analytics.identifyAll(providers)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, analytics];
+                }
+            });
+        });
+    };
+    /*
+      Public SDK functions
+    */
+    /**
+     * Emits a page visit event with the current URL information, fire on page change.
+     * @returns {Promise<void>}
+     */
+    FormoAnalytics.prototype.page = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.trackPageHit()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Emits a wallet connect event.
+     * @param {ChainID} params.chainId
+     * @param {Address} params.address
+     * @throws {Error} If chainId or address is empty
+     * @returns {Promise<void>}
+     */
+    FormoAnalytics.prototype.connect = function (_a) {
+        return __awaiter(this, arguments, void 0, function (_b) {
+            var chainId = _b.chainId, address = _b.address;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!chainId) {
+                            throw new Error("FormoAnalytics::connect: chain ID cannot be empty");
+                        }
+                        if (!address) {
+                            throw new Error("FormoAnalytics::connect: address cannot be empty");
+                        }
+                        this.currentChainId = chainId;
+                        this.currentConnectedAddress = address;
+                        return [4 /*yield*/, this.trackEvent(Event.CONNECT, {
+                                chainId: chainId,
+                                address: address,
+                            })];
+                    case 1:
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Emits a wallet disconnect event.
+     * @param {ChainID} params.chainId
+     * @param {Address} params.address
+     * @returns {Promise<void>}
+     */
+    FormoAnalytics.prototype.disconnect = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address, chainId;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = (params === null || params === void 0 ? void 0 : params.address) || this.currentConnectedAddress;
+                        chainId = (params === null || params === void 0 ? void 0 : params.chainId) || this.currentChainId;
+                        return [4 /*yield*/, this.handleDisconnect(chainId, address)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Emits a chain network change event.
+     * @param {ChainID} params.chainId
+     * @param {Address} params.address
+     * @throws {Error} If chainId is empty, zero, or not a valid number
+     * @throws {Error} If no address is provided and no previous address is recorded
+     * @returns {Promise<void>}
+     */
+    FormoAnalytics.prototype.chain = function (_a) {
+        return __awaiter(this, arguments, void 0, function (_b) {
+            var chainId = _b.chainId, address = _b.address;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!chainId || Number(chainId) === 0) {
+                            throw new Error("FormoAnalytics::chain: chainId cannot be empty or 0");
+                        }
+                        if (isNaN(Number(chainId))) {
+                            throw new Error("FormoAnalytics::chain: chainId must be a valid decimal number");
+                        }
+                        if (!address && !this.currentConnectedAddress) {
+                            throw new Error("FormoAnalytics::chain: address was empty and no previous address has been recorded");
+                        }
+                        this.currentChainId = chainId;
+                        return [4 /*yield*/, this.trackEvent(Event.CHAIN_CHANGED, {
+                                chainId: chainId,
+                                address: address || this.currentConnectedAddress,
+                            })];
+                    case 1:
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Emits a signature event.
+     * @param {SignatureStatus} params.status - requested, confirmed, rejected
+     * @param {ChainID} params.chainId
+     * @param {Address} params.address
+     * @param {string} params.message
+     * @param {string} params.signatureHash - only provided if status is confirmed
+     * @returns {Promise<void>}
+     */
+    FormoAnalytics.prototype.signature = function (_a) {
+        return __awaiter(this, arguments, void 0, function (_b) {
+            var status = _b.status, chainId = _b.chainId, address = _b.address, message = _b.message, signatureHash = _b.signatureHash;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.trackEvent(Event.SIGNATURE, __assign({ status: status, chainId: chainId, address: address, message: message }, (signatureHash && { signatureHash: signatureHash })))];
+                    case 1:
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Emits a transaction event.
+     * @param {TransactionStatus} params.status - started, broadcasted, rejected
+     * @param {ChainID} params.chainId
+     * @param {Address} params.address
+     * @param {string} params.data
+     * @param {string} params.to
+     * @param {string} params.value
+     * @param {string} params.transactionHash - only provided if status is broadcasted
+     * @returns {Promise<void>}
+     */
+    FormoAnalytics.prototype.transaction = function (_a) {
+        return __awaiter(this, arguments, void 0, function (_b) {
+            var status = _b.status, chainId = _b.chainId, address = _b.address, data = _b.data, to = _b.to, value = _b.value, transactionHash = _b.transactionHash;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.trackEvent(Event.TRANSACTION, __assign({ status: status, chainId: chainId, address: address, data: data, to: to, value: value }, (transactionHash && { transactionHash: transactionHash })))];
+                    case 1:
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Emits an identify event with current wallet address.
+     * @param {Address} params.address
+     * @returns {Promise<void>}
+     */
+    FormoAnalytics.prototype.identify = function (_a) {
+        return __awaiter(this, arguments, void 0, function (_b) {
+            var address = _b.address, providerName = _b.providerName, rdns = _b.rdns;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (this.session.isIdentified())
+                            return [2 /*return*/, console.warn("FormoAnalytics::identify: Wallet already identified in this session")];
+                        this.session.identify();
+                        return [4 /*yield*/, this.trackEvent(Event.IDENTIFY, {
+                                address: address,
+                                providerName: providerName,
+                                rdns: rdns,
+                            })];
+                    case 1:
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Emits a custom event with custom data.
+     * @param {string} action
+     * @param {Record<string, any>} payload
+     * @returns {Promise<void>}
+     */
+    FormoAnalytics.prototype.track = function (action, payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.trackEvent(action, payload)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /*
+      SDK tracking and event listener functions
+    */
+    FormoAnalytics.prototype.trackProvider = function (provider) {
+        if (provider === this._provider) {
+            console.warn("FormoAnalytics::trackProvider: Provider already tracked.");
+            return;
+        }
+        this.currentChainId = undefined;
+        this.currentConnectedAddress = undefined;
+        if (this._provider) {
+            var actions = Object.keys(this._providerListeners);
+            for (var _i = 0, actions_1 = actions; _i < actions_1.length; _i++) {
+                var action = actions_1[_i];
+                this._provider.removeListener(action, this._providerListeners[action]);
+                delete this._providerListeners[action];
+            }
+        }
+        this._provider = provider;
+        // Register listeners for web3 provider events
+        this.registerAddressChangedListener();
+        this.registerChainChangedListener();
+        this.registerSignatureListener();
+        this.registerTransactionListener();
+    };
+    FormoAnalytics.prototype.registerAddressChangedListener = function () {
+        var _this = this;
+        var _a, _b;
+        var listener = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return _this.onAddressChanged(args[0]);
+        };
+        (_a = this._provider) === null || _a === void 0 ? void 0 : _a.on("accountsChanged", listener);
+        this._providerListeners["accountsChanged"] = listener;
+        var onAddressDisconnected = this.onAddressDisconnected.bind(this);
+        (_b = this._provider) === null || _b === void 0 ? void 0 : _b.on("disconnect", onAddressDisconnected);
+        this._providerListeners["disconnect"] = onAddressDisconnected;
+    };
+    FormoAnalytics.prototype.registerChainChangedListener = function () {
+        var _this = this;
+        var _a;
+        var listener = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return _this.onChainChanged(args[0]);
+        };
+        (_a = this.provider) === null || _a === void 0 ? void 0 : _a.on("chainChanged", listener);
+        this._providerListeners["chainChanged"] = listener;
+    };
+    FormoAnalytics.prototype.registerSignatureListener = function () {
+        var _this = this;
+        var _a;
+        if (!this.provider) {
+            console.error("_trackSigning: provider not found");
+            return;
+        }
+        if (((_a = Object.getOwnPropertyDescriptor(this.provider, "request")) === null || _a === void 0 ? void 0 : _a.writable) ===
+            false) {
+            console.warn("_trackSigning: provider.request is not writable");
+            return;
+        }
+        var request = this.provider.request.bind(this.provider);
+        this.provider.request = function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+            var response, error_1, rpcError;
+            var method = _b.method, params = _b.params;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(Array.isArray(params) &&
+                            ["eth_signTypedData_v4", "personal_sign"].includes(method))) return [3 /*break*/, 4];
+                        // Emit signature request event
+                        this.signature(__assign({ status: SignatureStatus.REQUESTED }, this.buildSignatureEventPayload(method, params)));
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, request({ method: method, params: params })];
+                    case 2:
+                        response = (_c.sent());
+                        if (response) {
+                            // Emit signature confirmed event
+                            this.signature(__assign({ status: SignatureStatus.CONFIRMED }, this.buildSignatureEventPayload(method, params, response)));
+                        }
+                        return [2 /*return*/, response];
+                    case 3:
+                        error_1 = _c.sent();
+                        rpcError = error_1;
+                        if (rpcError && (rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
+                            // Emit signature rejected event
+                            this.signature(__assign({ status: SignatureStatus.REJECTED }, this.buildSignatureEventPayload(method, params)));
+                        }
+                        throw error_1;
+                    case 4: return [2 /*return*/, request({ method: method, params: params })];
+                }
+            });
+        }); };
+        return;
+    };
+    FormoAnalytics.prototype.registerTransactionListener = function () {
+        var _this = this;
+        var _a;
+        if (!this.provider) {
+            console.error("_trackTransactions: provider not found");
+            return;
+        }
+        if (((_a = Object.getOwnPropertyDescriptor(this.provider, "request")) === null || _a === void 0 ? void 0 : _a.writable) ===
+            false) {
+            console.warn("_trackTransactions: provider.request is not writable");
+            return;
+        }
+        var request = this.provider.request.bind(this.provider);
+        this.provider.request = function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+            var payload, transactionHash, error_2, rpcError;
+            var method = _b.method, params = _b.params;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(Array.isArray(params) &&
+                            method === "eth_sendTransaction" &&
+                            params[0])) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.buildTransactionEventPayload(params)];
+                    case 1:
+                        payload = _c.sent();
+                        this.transaction(__assign({ status: TransactionStatus.STARTED }, payload));
+                        _c.label = 2;
+                    case 2:
+                        _c.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, request({ method: method, params: params })];
+                    case 3:
+                        transactionHash = (_c.sent());
+                        // Track transaction broadcast
+                        this.transaction(__assign(__assign({ status: TransactionStatus.BROADCASTED }, payload), { transactionHash: transactionHash }));
+                        return [2 /*return*/];
+                    case 4:
+                        error_2 = _c.sent();
+                        console.log("transaction listener catch");
+                        console.log(error_2);
+                        rpcError = error_2;
+                        if (rpcError && (rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
+                            // Emit transaction rejected event
+                            this.transaction(__assign({ status: TransactionStatus.REJECTED }, payload));
+                        }
+                        throw error_2;
+                    case 5: return [2 /*return*/, request({ method: method, params: params })];
+                }
+            });
+        }); };
+        return;
+    };
+    FormoAnalytics.prototype.onAddressChanged = function (addresses) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (addresses.length > 0) {
+                    this.onAddressConnected(addresses[0]);
+                }
+                else {
+                    this.onAddressDisconnected();
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    FormoAnalytics.prototype.onAddressConnected = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (address === this.currentConnectedAddress) {
+                            // We have already reported this address
+                            return [2 /*return*/];
+                        }
+                        else {
+                            this.currentConnectedAddress = address;
+                        }
+                        _a = this;
+                        return [4 /*yield*/, this.getCurrentChainId()];
+                    case 1:
+                        _a.currentChainId = _b.sent();
+                        this.connect({ chainId: this.currentChainId, address: address });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FormoAnalytics.prototype.handleDisconnect = function (chainId, address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        payload = {
+                            chain_id: chainId || this.currentChainId,
+                            address: address || this.currentConnectedAddress,
+                        };
+                        this.currentChainId = undefined;
+                        this.currentConnectedAddress = undefined;
+                        return [4 /*yield*/, this.trackEvent(Event.DISCONNECT, payload)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FormoAnalytics.prototype.onAddressDisconnected = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.handleDisconnect(this.currentChainId, this.currentConnectedAddress)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FormoAnalytics.prototype.onChainChanged = function (chainIdHex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.currentChainId = parseInt(chainIdHex);
+                        if (!!this.currentConnectedAddress) return [3 /*break*/, 2];
+                        if (!this.provider) {
+                            console.log("FormoAnalytics::onChainChanged: provider not found. CHAIN_CHANGED not reported");
+                            return [2 /*return*/, Promise.resolve()];
+                        }
+                        return [4 /*yield*/, this.getAddress()];
+                    case 1:
+                        address = _a.sent();
+                        if (!address) {
+                            console.log("FormoAnalytics::onChainChanged: Unable to fetch or store connected address");
+                            return [2 /*return*/, Promise.resolve()];
+                        }
+                        this.currentConnectedAddress = address;
+                        _a.label = 2;
+                    case 2:
+                        // Proceed only if the address exists
+                        if (this.currentConnectedAddress) {
+                            return [2 /*return*/, this.chain({
+                                    chainId: this.currentChainId,
+                                    address: this.currentConnectedAddress,
+                                })];
+                        }
+                        else {
+                            console.log("FormoAnalytics::onChainChanged: currentConnectedAddress is null despite fetch attempt");
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FormoAnalytics.prototype.trackFirstPageHit = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (session.get(CURRENT_URL_KEY) === null) {
+                    session.set(CURRENT_URL_KEY, window.location.href);
+                }
+                return [2 /*return*/, this.trackPageHit()];
+            });
+        });
+    };
+    FormoAnalytics.prototype.trackPageHits = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var oldPushState, oldReplaceState;
+            var _this = this;
+            return __generator(this, function (_a) {
+                oldPushState = history.pushState;
+                history.pushState = function pushState() {
+                    var args = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        args[_i] = arguments[_i];
+                    }
+                    var ret = oldPushState.apply(this, args);
+                    window.dispatchEvent(new window.Event("locationchange"));
+                    return ret;
+                };
+                oldReplaceState = history.replaceState;
+                history.replaceState = function replaceState() {
+                    var args = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        args[_i] = arguments[_i];
+                    }
+                    var ret = oldReplaceState.apply(this, args);
+                    window.dispatchEvent(new window.Event("locationchange"));
+                    return ret;
+                };
+                window.addEventListener("popstate", function () { return _this.onLocationChange(); });
+                window.addEventListener("locationchange", function () { return _this.onLocationChange(); });
+                return [2 /*return*/];
+            });
+        });
+    };
+    FormoAnalytics.prototype.onLocationChange = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var currentUrl;
+            return __generator(this, function (_a) {
+                currentUrl = session.get(CURRENT_URL_KEY);
+                if (currentUrl !== window.location.href) {
+                    session.set(CURRENT_URL_KEY, window.location.href);
+                    this.trackPageHit();
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    FormoAnalytics.prototype.trackPageHit = function () {
+        var _this = this;
+        var pathname = window.location.pathname;
+        var href = window.location.href;
+        var hash = window.location.hash;
+        if (!this.config.trackLocalhost && isLocalhost()) {
+            return console.warn("FormoAnalytics::trackPageHit: Ignoring event because website is running locally");
+        }
+        setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.trackEvent(Event.PAGE, {
+                    pathname: pathname,
+                    href: href,
+                    hash: hash,
+                });
+                return [2 /*return*/];
+            });
+        }); }, 300);
+    };
+    // TODO: refactor this with event queue and flushing
+    // https://linear.app/getformo/issue/P-835/sdk-refactor-retries-with-event-queue-and-batching
+    FormoAnalytics.prototype.trackEvent = function (action, payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address, requestData, response, error_3;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.getAddress()];
+                    case 1:
+                        address = _b.sent();
+                        _a = {
+                            address: address,
+                            timestamp: new Date().toISOString(),
+                            action: action,
+                            version: "1"
+                        };
+                        return [4 /*yield*/, this.buildEventPayload(toSnakeCase(payload))];
+                    case 2:
+                        requestData = (_a.payload = _b.sent(),
+                            _a);
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, axios.post(EVENTS_API_URL, JSON.stringify(requestData), {
+                                headers: {
+                                    "Content-Type": "application/json",
+                                    Authorization: "Bearer ".concat(this.config.apiKey),
+                                },
+                            })];
+                    case 4:
+                        response = _b.sent();
+                        if (response.status >= 200 && response.status < 300) {
+                            console.log("Event sent successfully: ".concat(this.getActionDescriptor(action, payload)));
+                        }
+                        else {
+                            throw new Error("Failed with status: ".concat(response.status));
+                        }
+                        return [3 /*break*/, 6];
+                    case 5:
+                        error_3 = _b.sent();
+                        console.error("Event \"".concat(action, "\" failed. Error: ").concat(error_3));
+                        return [3 /*break*/, 6];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /*
+      Utility functions
+    */
+    FormoAnalytics.prototype.getProviders = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var store, providers;
+            return __generator(this, function (_a) {
+                store = createStore();
+                providers = __spreadArray([], store.getProviders(), true);
+                // TODO: consider using store.subscribe to detect changes to providers list
+                // store.subscribe(providers => (state.providers = providers))
+                // Fallback to injected provider if no providers are found
+                if (providers.length === 0) {
+                    return [2 /*return*/, [window === null || window === void 0 ? void 0 : window.ethereum]];
+                }
+                return [2 /*return*/, providers];
+            });
+        });
+    };
+    FormoAnalytics.prototype.identifyAll = function (providers) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, providers_1, _a, provider, info, accounts, _b, accounts_1, address, err_1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _i = 0, providers_1 = providers;
+                        _c.label = 1;
+                    case 1:
+                        if (!(_i < providers_1.length)) return [3 /*break*/, 13];
+                        _a = providers_1[_i], provider = _a.provider, info = _a.info;
+                        _c.label = 2;
+                    case 2:
+                        _c.trys.push([2, 11, , 12]);
+                        return [4 /*yield*/, this.getAccounts(provider)];
+                    case 3:
+                        accounts = _c.sent();
+                        if (!(accounts && accounts.length > 0)) return [3 /*break*/, 8];
+                        _b = 0, accounts_1 = accounts;
+                        _c.label = 4;
+                    case 4:
+                        if (!(_b < accounts_1.length)) return [3 /*break*/, 7];
+                        address = accounts_1[_b];
+                        return [4 /*yield*/, this.identify({
+                                address: address,
+                                providerName: info.name,
+                                rdns: info.rdns,
+                            })];
+                    case 5:
+                        _c.sent();
+                        _c.label = 6;
+                    case 6:
+                        _b++;
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
+                    case 8: 
+                    // Identify without accounts
+                    return [4 /*yield*/, this.identify({
+                            address: null,
+                            providerName: info.name,
+                            rdns: info.rdns,
+                        })];
+                    case 9:
+                        // Identify without accounts
+                        _c.sent();
+                        _c.label = 10;
+                    case 10: return [3 /*break*/, 12];
+                    case 11:
+                        err_1 = _c.sent();
+                        console.log("identifying all => err", err_1);
+                        return [3 /*break*/, 12];
+                    case 12:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 13: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Object.defineProperty(FormoAnalytics.prototype, "provider", {
+        get: function () {
+            return this._provider;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FormoAnalytics.prototype.getAddress = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var accounts, err_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.currentConnectedAddress)
+                            return [2 /*return*/, this.currentConnectedAddress];
+                        if (!this.provider) {
+                            console.log("FormoAnalytics::getAddress: the provider is not set");
+                            return [2 /*return*/, null];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.getAccounts()];
+                    case 2:
+                        accounts = _a.sent();
+                        if (accounts && accounts.length > 0) {
+                            return [2 /*return*/, accounts[0]];
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_2 = _a.sent();
+                        console.log("Failed to fetch accounts from provider:", err_2);
+                        return [2 /*return*/, null];
+                    case 4: return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    FormoAnalytics.prototype.getAccounts = function (provider) {
+        return __awaiter(this, void 0, void 0, function () {
+            var p, res, err_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        p = provider || this.provider;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, (p === null || p === void 0 ? void 0 : p.request({
+                                method: "eth_accounts",
+                            }))];
+                    case 2:
+                        res = _a.sent();
+                        if (!res || res.length === 0)
+                            return [2 /*return*/, null];
+                        return [2 /*return*/, res];
+                    case 3:
+                        err_3 = _a.sent();
+                        if (err_3.code !== 4001) {
+                            console.log("FormoAnalytics::getAccounts: eth_accounts threw an error", err_3);
+                        }
+                        return [2 /*return*/, null];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FormoAnalytics.prototype.getCurrentChainId = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var chainIdHex, err_4;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this.provider) {
+                            console.error("FormoAnalytics::getCurrentChainId: provider not set");
+                        }
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, ((_a = this.provider) === null || _a === void 0 ? void 0 : _a.request({
+                                method: "eth_chainId",
+                            }))];
+                    case 2:
+                        chainIdHex = _b.sent();
+                        if (!chainIdHex) {
+                            console.log("FormoAnalytics::fetchChainId: chain id not found");
+                            return [2 /*return*/, 0];
+                        }
+                        return [2 /*return*/, parseInt(chainIdHex, 16)];
+                    case 3:
+                        err_4 = _b.sent();
+                        console.log("FormoAnalytics::fetchChainId: eth_chainId threw an error", err_4);
+                        return [2 /*return*/, 0];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FormoAnalytics.prototype.getLocation = function () {
+        try {
+            var timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            if (timezone in COUNTRY_LIST)
+                return COUNTRY_LIST[timezone];
+            return timezone;
+        }
+        catch (error) {
+            console.error("Error resolving timezone:", error);
+            return "";
+        }
+    };
+    FormoAnalytics.prototype.getLanguage = function () {
+        try {
+            return ((navigator.languages && navigator.languages.length
+                ? navigator.languages[0]
+                : navigator.language) || "en");
+        }
+        catch (error) {
+            console.error("Error resolving language:", error);
+            return "en";
+        }
+    };
+    // Adds browser properties to the user-supplied payload
+    FormoAnalytics.prototype.buildEventPayload = function () {
+        return __awaiter(this, arguments, void 0, function (eventSpecificPayload) {
+            var url, params, location, language;
+            if (eventSpecificPayload === void 0) { eventSpecificPayload = {}; }
+            return __generator(this, function (_a) {
+                url = new URL(window.location.href);
+                params = new URLSearchParams(url.search);
+                location = this.getLocation();
+                language = this.getLanguage();
+                // common browser properties
+                return [2 /*return*/, __assign({ "user-agent": window.navigator.userAgent, origin: url.origin, locale: language, location: location, referrer: document.referrer, utm_source: params.get("utm_source"), utm_medium: params.get("utm_medium"), utm_campaign: params.get("utm_campaign"), ref: params.get("ref") }, eventSpecificPayload)];
+            });
+        });
+    };
+    FormoAnalytics.prototype.buildSignatureEventPayload = function (method, params, response) {
+        var basePayload = {
+            chainId: this.currentChainId,
+            address: method === "personal_sign"
+                ? params[1]
+                : params[0],
+        };
+        if (method === "personal_sign") {
+            var message = Buffer.from(params[0].slice(2), "hex").toString("utf8");
+            return __assign(__assign(__assign({}, basePayload), { message: message }), (response ? { signatureHash: response } : {}));
+        }
+        return __assign(__assign(__assign({}, basePayload), { message: params[1] }), (response ? { signatureHash: response } : {}));
+    };
+    FormoAnalytics.prototype.buildTransactionEventPayload = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, data, from, to, value, _b;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _a = params[0], data = _a.data, from = _a.from, to = _a.to, value = _a.value;
+                        _c = {};
+                        _b = this.currentChainId;
+                        if (_b) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.getCurrentChainId()];
+                    case 1:
+                        _b = (_d.sent());
+                        _d.label = 2;
+                    case 2: return [2 /*return*/, (_c.chainId = _b,
+                            _c.data = data,
+                            _c.address = from,
+                            _c.to = to,
+                            _c.value = value,
+                            _c)];
+                }
+            });
+        });
+    };
+    FormoAnalytics.prototype.getActionDescriptor = function (action, payload) {
+        return "".concat(action).concat(payload.status ? " ".concat(payload.status) : "");
+    };
+    return FormoAnalytics;
+}());
+export { FormoAnalytics };
+var FormoAnalyticsSession = /** @class */ (function () {
+    function FormoAnalyticsSession() {
+    }
+    FormoAnalyticsSession.prototype.isIdentified = function () {
+        return session.get(SESSION_IDENTIFIED_KEY) === true;
+    };
+    FormoAnalyticsSession.prototype.identify = function () {
+        session.set(SESSION_IDENTIFIED_KEY, true);
+    };
+    return FormoAnalyticsSession;
+}());
+//# sourceMappingURL=FormoAnalytics.js.map