@formo/analytics 1.12.0-alpha.2 → 1.12.0

package/src/FormoAnalytics.ts

@@ -1,25 +1,13 @@
-import axios from 'axios';
+import axios from "axios";
 import {
   COUNTRY_LIST,
-  EVENTS_API,
-  SESSION_STORAGE_ID_KEY,
+  EVENTS_API_URL,
   Event,
-} from './constants';
-import { isNotEmpty } from './utils';
-import { H } from 'highlight.run';
-import { ChainID, EIP1193Provider, RequestArguments } from './types';
+} from "./constants";
+import { H } from "highlight.run";
+import { ChainID, Address, EIP1193Provider, Options, Config } from "./types";
 
 interface IFormoAnalytics {
-  /**
-   * Initializes the FormoAnalytics instance with the provided API key and project ID.
-   */
-  init(apiKey: string, projectId: string): Promise<FormoAnalytics>;
-
-  /**
-   * Identifies the user with the provided user data.
-   */
-  identify(userData: Record<string, any>): void;
-
   /**
    * Tracks page visit events.
    */
@@ -28,47 +16,45 @@ interface IFormoAnalytics {
   /**
    * Connects to a wallet with the specified chain ID and address.
    */
-  connect(params: { account: string; chainId: ChainID }): Promise<void>;
+  connect(params: { chainId: ChainID; address: string }): Promise<void>;
 
   /**
-   * Disconnects the current wallet and clears the session information.
+   * Disconnects the current wallet.
    */
-  disconnect(attributes?: { account?: string; chainId?: ChainID }): void;
+  disconnect(params?: { chainId?: ChainID; address?: string }): Promise<void>;
 
   /**
-   * Tracks a specific event with a name and associated data.
+   * Switches the blockchain chain context and optionally logs additional params.
    */
-  track(eventName: string, eventData: Record<string, any>): void;
+  chain(params: { chainId: ChainID; address?: string }): Promise<void>;
 
   /**
-   * Switches the blockchain chain context and optionally logs additional attributes.
+   * Tracks a specific event with a name and associated data.
    */
-  chain(attributes: { chainId: ChainID; account?: string }): void;
+  track(eventName: string, eventData: Record<string, any>): Promise<void>;
 }
+
 export class FormoAnalytics implements IFormoAnalytics {
   private _provider?: EIP1193Provider;
-  private _registeredProviderListeners: Record<
+  private _providerListeners: Record<
     string,
     (...args: unknown[]) => void
   > = {};
 
-  private sessionKey = 'walletAddress';
-  private config: any;
-  private sessionIdKey: string = SESSION_STORAGE_ID_KEY;
-  private timezoneToCountry: Record<string, string> = COUNTRY_LIST;
-
-  currentChainId?: string | null;
-  currentConnectedAccount?: string;
+  config: Config;
+  currentChainId?: ChainID;
+  currentConnectedAddress?: Address;
 
   private constructor(
     public readonly apiKey: string,
-    public projectId: string
+    public options: Options = {}
   ) {
     this.config = {
-      token: this.apiKey,
+      apiKey: apiKey,
     };
 
-    const provider = window?.ethereum || window.web3?.currentProvider;
+    const provider =
+      window?.ethereum || window.web3?.currentProvider || options?.provider;
     if (provider) {
       this.trackProvider(provider);
     }
@@ -76,514 +62,373 @@ export class FormoAnalytics implements IFormoAnalytics {
 
   static async init(
     apiKey: string,
-    projectId: string
+    options?: Options
   ): Promise<FormoAnalytics> {
-    const config = {
-      token: apiKey,
-    };
-    const instance = new FormoAnalytics(apiKey, projectId);
-    instance.config = config;
-
-    return instance;
+    // May be needed for delayed loading
+    // https://github.com/segmentio/analytics-next/tree/master/packages/browser#lazy--delayed-loading
+    return new FormoAnalytics(apiKey, options);
   }
 
-  get provider(): EIP1193Provider | undefined {
-    return this._provider;
-  }
-
-  private identifyUser(userData: any) {
-    this.trackEvent(Event.IDENTIFY, userData);
-  }
-
-  private getSessionId() {
-    const existingSessionId = this.getCookieValue(this.sessionIdKey);
+  /*
+    Public SDK functions
+  */
 
-    if (existingSessionId) {
-      return existingSessionId;
+  async connect({ chainId, address }: { chainId: ChainID; address: Address }): Promise<void> {
+    if (!chainId) {
+      throw new Error("FormoAnalytics::connect: chain ID cannot be empty");
     }
-
-    const newSessionId = this.generateSessionId();
-    return newSessionId;
-  }
-
-  // Function to set the session cookie
-  private setSessionCookie(domain?: string) {
-    const sessionId = this.getSessionId();
-    let cookieValue = `${this.sessionIdKey}=${sessionId}; Max-Age=1800; path=/; secure`;
-    if (domain) {
-      cookieValue += `; domain=${domain}`;
+    if (!address) {
+      throw new Error("FormoAnalytics::connect: address cannot be empty");
     }
-    document.cookie = cookieValue;
-  }
-
-  // Function to generate a new session ID
-  private generateSessionId(): string {
-    return crypto.randomUUID();
-  }
-
-  // Function to get a cookie value by name
-  private getCookieValue(name: string): string | undefined {
-    const cookies = document.cookie.split(';').reduce((acc, cookie) => {
-      const [key, value] = cookie.split('=');
-      acc[key.trim()] = value;
-      return acc;
-    }, {} as Record<string, string>);
-    return cookies[name];
-  }
-
-  // Function to send tracking data
-  private async trackEvent(action: string, payload: any) {
-    const maxRetries = 3;
-    let attempt = 0;
 
-    this.setSessionCookie(this.config.domain);
-    const apiUrl = this.buildApiUrl();
-    const address = await this.getCurrentWallet();
+    this.currentChainId = chainId;
+    this.currentConnectedAddress = address;
 
-    const requestData = {
-      project_id: this.projectId,
+    await this.trackEvent(Event.CONNECT, {
+      chain_id: chainId,
       address: address,
-      session_id: this.getSessionId(),
-      timestamp: new Date().toISOString(),
-      action: action,
-      version: '1',
-      payload: isNotEmpty(payload) ? this.maskSensitiveData(payload) : payload,
-    };
-
-    const sendRequest = async (): Promise<void> => {
-      try {
-        const response = await axios.post(apiUrl, JSON.stringify(requestData), {
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        });
-
-        if (response.status >= 200 && response.status < 300) {
-          console.log('Event sent successfully:', action);
-        } else {
-          throw new Error(`Failed with status: ${response.status}`);
-        }
-      } catch (error) {
-        attempt++;
-
-        if (attempt <= maxRetries) {
-          const retryDelay = Math.pow(2, attempt) * 1000;
-          console.error(
-            `Attempt ${attempt}: Retrying event "${action}" in ${
-              retryDelay / 1000
-            } seconds...`
-          );
-          setTimeout(sendRequest, retryDelay);
-        } else {
-          H.consumeError(
-            error as Error,
-            `Request data: ${JSON.stringify(requestData)}`
-          );
-          console.error(
-            `Event "${action}" failed after ${maxRetries} attempts. Error: ${error}`
-          );
-        }
-      }
-    };
+    });
+  }
 
-    await sendRequest();
+  async disconnect(params?: { chainId?: ChainID; address?: Address }): Promise<void> {
+    const address = params?.address || this.currentConnectedAddress;
+    const chainId = params?.chainId || this.currentChainId;
+    await this.handleDisconnect(chainId, address);
   }
 
-  // Function to mask sensitive data in the payload
-  private maskSensitiveData(
-    data: string | undefined | null
-  ): Record<string, any> | null {
-    // Check if data is null or undefined
-    if (data === null || data === undefined) {
-      console.warn('Data is null or undefined, returning null');
-      return null;
+  async chain({ chainId, address }: { chainId: ChainID; address?: Address }): Promise<void> {
+    if (!chainId || Number(chainId) === 0) {
+      throw new Error("FormoAnalytics::chain: chainId cannot be empty or 0");
     }
-
-    // Check if data is a string; if so, parse it to an object
-    if (typeof data === 'string') {
-      let parsedData: Record<string, any>;
-      try {
-        parsedData = JSON.parse(data);
-      } catch (error) {
-        console.error('Failed to parse JSON:', error);
-        return null; // Return null if parsing fails
-      }
-
-      const sensitiveFields = [
-        'username',
-        'user',
-        'user_id',
-        'password',
-        'email',
-        'phone',
-      ];
-
-      // Create a new object to store masked data
-      const maskedData = { ...parsedData };
-
-      // Mask sensitive fields
-      sensitiveFields.forEach((field) => {
-        if (field in maskedData) {
-          maskedData[field] = '********'; // Replace value with masked string
-        }
-      });
-
-      return maskedData; // Return the new object with masked fields
-    } else if (typeof data === 'object') {
-      // If data is already an object, handle masking directly
-      const sensitiveFields = [
-        'username',
-        'user',
-        'user_id',
-        'password',
-        'email',
-        'phone',
-      ];
-
-      const maskedData = { ...(data as Record<string, any>) };
-
-      // Mask sensitive fields
-      sensitiveFields.forEach((field) => {
-        if (field in maskedData) {
-          maskedData[field] = '********'; // Replace value with masked string
-        }
-      });
-
-      return maskedData; // Return the new object with masked fields
+    if (!address && !this.currentConnectedAddress) {
+      throw new Error(
+        "FormoAnalytics::chain: address was empty and no previous address has been recorded. You can either pass an address or call connect() first"
+      );
+    }
+    if (isNaN(Number(chainId))) {
+      throw new Error(
+        "FormoAnalytics::chain: chainId must be a valid decimal number"
+      );
     }
 
-    return data;
-  }
+    this.currentChainId = chainId;
 
-  // Function to track page hits
-  private trackPageHit() {
-    if (window.__nightmare || window.navigator.webdriver || window.Cypress)
-      return;
+    await this.trackEvent(Event.CHAIN_CHANGED, {
+      chain_id: chainId,
+      address: address || this.currentConnectedAddress,
+    });
+  }
 
-    let location: string | undefined;
-    let language: string;
-    try {
-      const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-      location = this.timezoneToCountry[timezone];
-      language =
-        navigator.languages && navigator.languages.length
-          ? navigator.languages[0]
-          : navigator.language || 'en';
-    } catch (error) {
-      console.error('Error resolving timezone or language:', error);
-    }
+  // TODO: allow custom url as input
+  async page(): Promise<void> {
+    await this.trackPageHit();
+  }
 
-    setTimeout(() => {
-      const url = new URL(window.location.href);
-      const params = new URLSearchParams(url.search);
-      this.trackEvent(Event.PAGE, {
-        'user-agent': window.navigator.userAgent,
-        locale: language,
-        location: location,
-        referrer: document.referrer,
-        pathname: window.location.pathname,
-        href: window.location.href,
-        utm_source: params.get('utm_source'),
-        utm_medium: params.get('utm_medium'),
-        utm_campaign: params.get('utm_campaign'),
-        ref: params.get('ref'),
-      });
-    }, 300);
+  async track(eventName: string, eventData: Record<string, any>): Promise<void> {
+    await this.trackEvent(eventName, eventData);
   }
 
-  private trackProvider(provider: EIP1193Provider) {
+  /*
+    SDK tracking and event listener functions
+  */
+
+  private trackProvider(provider: EIP1193Provider): void {
     if (provider === this._provider) {
+      console.log("Provider already tracked.");
       return;
     }
 
     this.currentChainId = undefined;
-    this.currentConnectedAccount = undefined;
+    this.currentConnectedAddress = undefined;
 
     if (this._provider) {
-      const eventNames = Object.keys(this._registeredProviderListeners);
+      const eventNames = Object.keys(this._providerListeners);
       for (const eventName of eventNames) {
         this._provider.removeListener(
           eventName,
-          this._registeredProviderListeners[eventName]
+          this._providerListeners[eventName]
         );
-        delete this._registeredProviderListeners[eventName];
+        delete this._providerListeners[eventName];
       }
     }
 
+    console.log("Tracking new provider:", provider);
     this._provider = provider;
 
-    this.getCurrentWallet();
-    this.registerAccountsChangedListener();
+    this.getAddress();
+    this.registerAddressChangedListener();
     this.registerChainChangedListener();
+    // TODO: track signing and transactions
+    // https://linear.app/getformo/issue/P-607/sdk-support-signature-and-transaction-events
+  }
+
+  private registerAddressChangedListener(): void {
+    const listener = (...args: unknown[]) =>
+      this.onAddressChanged(args[0] as string[]);
+
+    this._provider?.on("accountsChanged", listener);
+    this._providerListeners["accountsChanged"] = listener;
+
+    const onAddressDisconnected = this.onAddressDisconnected.bind(this);
+    this._provider?.on("disconnect", onAddressDisconnected);
+    this._providerListeners["disconnect"] = onAddressDisconnected;
   }
 
-  private registerChainChangedListener() {
+  private registerChainChangedListener(): void {
     const listener = (...args: unknown[]) =>
       this.onChainChanged(args[0] as string);
-    this.provider?.on('chainChanged', listener);
-    this._registeredProviderListeners['chainChanged'] = listener;
+    this.provider?.on("chainChanged", listener);
+    this._providerListeners["chainChanged"] = listener;
+  }
+
+  private async onAddressChanged(addresses: Address[]): Promise<void> {
+    if (addresses.length > 0) {
+      this.onAddressConnected(addresses[0]);
+    } else {
+      this.onAddressDisconnected();
+    }
   }
 
-  private handleAccountDisconnected() {
-    if (!this.currentConnectedAccount) {
+  private async onAddressConnected(address: Address): Promise<void> {
+    if (address === this.currentConnectedAddress) {
+      // We have already reported this address
       return;
+    } else {
+      this.currentConnectedAddress = address;
     }
 
-    const disconnectAttributes = {
-      account: this.currentConnectedAccount,
-      chainId: this.currentChainId,
+    this.currentChainId = await this.getCurrentChainId();
+    this.connect({ chainId: this.currentChainId, address });
+  }
+
+  private async handleDisconnect(chainId?: ChainID, address?: Address): Promise<void> {
+    const payload = {
+      chain_id: chainId || this.currentChainId,
+      address: address || this.currentConnectedAddress,
     };
     this.currentChainId = undefined;
-    this.currentConnectedAccount = undefined;
-    this.clearWalletAddress();
+    this.currentConnectedAddress = undefined;
+    await this.trackEvent(Event.DISCONNECT, payload);
+  }
 
-    return this.trackEvent(Event.DISCONNECT, disconnectAttributes);
+  private async onAddressDisconnected(): Promise<void> {
+    await this.handleDisconnect(this.currentChainId, this.currentConnectedAddress);
   }
 
-  private async onChainChanged(chainIdHex: string) {
-    this.currentChainId = parseInt(chainIdHex).toString();
-    if (!this.currentConnectedAccount) {
+  private async onChainChanged(chainIdHex: string): Promise<void> {
+    this.currentChainId = parseInt(chainIdHex);
+    if (!this.currentConnectedAddress) {
       if (!this.provider) {
-        console.error(
-          'error',
-          'FormoAnalytics::onChainChanged: provider not found. CHAIN_CHANGED not reported'
+        console.log(
+          "FormoAnalytics::onChainChanged: provider not found. CHAIN_CHANGED not reported"
         );
-        return;
+        return Promise.resolve();
       }
 
-      try {
-        const res: string[] | null | undefined = await this.provider.request({
-          method: 'eth_accounts',
-        });
-        if (!res || res.length === 0) {
-          console.error(
-            'error',
-            'FormoAnalytics::onChainChanged: unable to get account. eth_accounts returned empty'
-          );
-          return;
-        }
-
-        this.currentConnectedAccount = res[0];
-      } catch (err) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        if ((err as any).code !== 4001) {
-          // 4001: The request is rejected by the user , see https://docs.metamask.io/wallet/reference/provider-api/#errors
-          console.error(
-            'error',
-            `FormoAnalytics::onChainChanged: unable to get account. eth_accounts threw an error`,
-            err
-          );
-          return;
-        }
+      // Attempt to fetch and store the connected address
+      const address = await this.getAddress();
+      if (!address) {
+        console.log(
+          "FormoAnalytics::onChainChanged: Unable to fetch or store connected address"
+        );
+        return Promise.resolve();
       }
-    }
 
-    return this.chain({
-      chainId: this.currentChainId,
-      account: this.currentConnectedAccount,
-    });
-  }
+      this.currentConnectedAddress = address[0];
+    }
 
-  private async onAccountsChanged(accounts: string[]) {
-    if (accounts.length > 0) {
-      const newAccount = accounts[0];
-      if (newAccount !== this.currentConnectedAccount) {
-        this.handleAccountConnected(newAccount);
-      }
+    // Proceed only if the address exists
+    if (this.currentConnectedAddress) {
+      return this.chain({
+        chainId: this.currentChainId,
+        address: this.currentConnectedAddress,
+      });
     } else {
-      this.handleAccountDisconnected();
+      console.log(
+        "FormoAnalytics::onChainChanged: currentConnectedAddress is null despite fetch attempt"
+      );
     }
   }
 
-  private registerAccountsChangedListener() {
-    const listener = (...args: unknown[]) =>
-      this.onAccountsChanged(args[0] as string[]);
-
-    this._provider?.on('accountsChanged', listener);
-    this._registeredProviderListeners['accountsChanged'] = listener;
+  // TOFIX: support multiple page hit events
+  // TODO: Add event listener and support for SPA and hash-based navigation
+  // https://linear.app/getformo/issue/P-800/sdk-support-spa-and-hash-based-routing
+  private trackPageHit(): void {
+    const pathname = window.location.pathname;
+    const href = window.location.href;
 
-    const handleAccountDisconnected = this.handleAccountDisconnected.bind(this);
-    this._provider?.on('disconnect', handleAccountDisconnected);
-    this._registeredProviderListeners['disconnect'] = handleAccountDisconnected;
+    setTimeout(async () => {
+      this.trackEvent(Event.PAGE, {
+        pathname,
+        href,
+      });
+    }, 300);
   }
 
-  private async getCurrentChainId(): Promise<string> {
-    if (!this.provider) {
-      console.error('FormoAnalytics::getCurrentChainId: provider not set');
-    }
+  // TODO: refactor this with event queue and flushing 
+  // https://linear.app/getformo/issue/P-835/sdk-refactor-retries-with-event-queue-and-batching
+  private async trackEvent(action: string, payload: any): Promise<void> {
+    const address = await this.getAddress();
 
-    const chainIdHex = await this.provider?.request<string>({
-      method: 'eth_chainId',
-    });
-    // Because we're connected, the chainId cannot be null
-    if (!chainIdHex) {
-      console.error(
-        `FormoAnalytics::getCurrentChainId: chainIdHex is: ${chainIdHex}`
-      );
-    }
+    const requestData = {
+      address: address,
+      timestamp: new Date().toISOString(),
+      action,
+      version: "1",
+      payload: await this.buildEventPayload(payload),
+    };
 
-    return parseInt(chainIdHex as string, 16).toString();
-  }
+    try {
+      const response = await axios.post(
+        EVENTS_API_URL,
+        JSON.stringify(requestData),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.config.apiKey}`,
+          },
+        }
+      );
 
-  private async handleAccountConnected(account: string) {
-    if (account === this.currentConnectedAccount) {
-      // We have already reported this account
-      return;
-    } else {
-      this.currentConnectedAccount = account;
+      if (response.status >= 200 && response.status < 300) {
+        console.log("Event sent successfully:", action);
+      } else {
+        throw new Error(`Failed with status: ${response.status}`);
+      }
+    } catch (error) {
+      H.consumeError(
+        error as Error,
+        `Request data: ${JSON.stringify(requestData)}`
+      );
+      console.error(`Event "${action}" failed. Error: ${error}`);
     }
+  }
 
-    this.currentChainId = await this.getCurrentChainId();
+  /*
+    Utility functions
+  */
 
-    this.connect({ account, chainId: this.currentChainId });
-    this.storeWalletAddress(account);
-  }
+  get provider(): EIP1193Provider | undefined {
+    return this._provider;
+  }    
 
-  private async getCurrentWallet() {
+  private async getAddress(): Promise<Address | null> {
     if (!this.provider) {
-      console.warn('FormoAnalytics::getCurrentWallet: the provider is not set');
-      return;
-    }
-    const sessionData = sessionStorage.getItem(this.sessionKey);
-
-    if (!sessionData) {
+      console.log("FormoAnalytics::getAddress: the provider is not set");
       return null;
     }
 
-    const parsedData = JSON.parse(sessionData);
-    const sessionExpiry = 30 * 60 * 1000; // 30 minutes in milliseconds
-    const currentTime = Date.now();
-
-    if (currentTime - parsedData.timestamp > sessionExpiry) {
-      console.warn('Session expired. Ignoring wallet address.');
-      sessionStorage.removeItem(this.sessionKey); // Clear expired session data
-      return '';
-    }
-
-    this.handleAccountConnected(parsedData.address);
-    return parsedData.address || '';
-  }
-
-  /**
-   * Stores the wallet address in session storage when connected.
-   * @param address - The wallet address to store.
-   */
-  private storeWalletAddress(address: string): void {
-    if (!address) {
-      console.error('No wallet address provided to store.');
-      return;
+    try {
+      const accounts = await this.getAccounts();
+      if (accounts && accounts.length > 0) {
+        const address = accounts[0];
+        // TODO: how to handle multiple addresses? Should we emit a connect event here? Since the user has not manually connected
+        // https://linear.app/getformo/issue/P-691/sdk-detect-multiple-wallets-using-eip6963
+        this.onAddressConnected(address); 
+        return address;
+      }
+    } catch (err) {
+      console.log("Failed to fetch accounts from provider:", err);
+      return null;
     }
-
-    const sessionData = {
-      address,
-      timestamp: Date.now(),
-    };
-
-    sessionStorage.setItem(this.sessionKey, JSON.stringify(sessionData));
+    return null;
   }
 
-  /**
-   * Clears the wallet address from session storage when disconnected.
-   */
-  private clearWalletAddress(): void {
-    sessionStorage.removeItem(this.sessionKey);
-  }
-
-  // Function to build the API URL
-  private buildApiUrl(): string {
-    const { host, proxy, token, dataSource = 'analytics_events' } = this.config;
-    if (token) {
-      if (proxy) {
-        return `${proxy}/api/tracking`;
+  private async getAccounts(): Promise<Address[] | null> {
+    try {
+      const res: string[] | null | undefined = await this.provider?.request({
+        method: "eth_accounts",
+      });
+      if (!res || res.length === 0) {
+        console.log(
+          "FormoAnalytics::getAccounts: unable to get account. eth_accounts returned empty"
+        );
+        return null;
       }
-      if (host) {
-        return `${host.replace(
-          /\/+$/,
-          ''
-        )}/v0/events?name=${dataSource}&token=${token}`;
+      return res;
+    } catch (err) {
+      if ((err as any).code !== 4001) {
+        console.log(
+          "FormoAnalytics::getAccounts: eth_accounts threw an error",
+          err
+        );
       }
-      return `${EVENTS_API}?name=${dataSource}&token=${token}`;
+      return null;
     }
-    return 'Error: No token provided';
   }
 
-  connect({ account, chainId }: { account: string; chainId: ChainID }) {
-    if (!chainId) {
-      throw new Error('FormoAnalytics::connect: chainId cannot be empty');
-    }
-    if (!account) {
-      throw new Error('FormoAnalytics::connect: account cannot be empty');
+  private async getCurrentChainId(): Promise<number> {
+    if (!this.provider) {
+      console.error("FormoAnalytics::getCurrentChainId: provider not set");
     }
 
-    this.currentChainId = chainId.toString();
-    this.currentConnectedAccount = account;
-
-    return this.trackEvent(Event.CONNECT, {
-      chainId,
-      address: account,
-    });
-  }
-
-  disconnect(attributes?: { account?: string; chainId?: ChainID }) {
-    const account = attributes?.account || this.currentConnectedAccount;
-    if (!account) {
-      // We have most likely already reported this disconnection with the automatic
-      // `disconnect` detection
-      return;
+    let chainIdHex;
+    try {
+      chainIdHex = await this.provider?.request<string>({
+        method: "eth_chainId",
+      });
+      if (!chainIdHex) {
+        console.log(
+          "FormoAnalytics::fetchChainId: chain id not found"
+        );
+        return 0;
+      }
+      return parseInt(chainIdHex as string, 16);
+    } catch (err) {
+      console.log(
+        "FormoAnalytics::fetchChainId: eth_chainId threw an error",
+        err
+      );
+      return 0;
     }
-
-    const chainId = attributes?.chainId || this.currentChainId;
-    const eventAttributes = {
-      account,
-      ...(chainId && { chainId }),
-    };
-
-    this.currentChainId = undefined;
-    this.currentConnectedAccount = undefined;
-
-    return this.trackEvent(Event.DISCONNECT, eventAttributes);
   }
 
-  chain({ chainId, account }: { chainId: ChainID; account?: string }) {
-    if (!chainId || Number(chainId) === 0) {
-      throw new Error('FormoAnalytics::chain: chainId cannot be empty or 0');
-    }
-
-    if (!account && !this.currentConnectedAccount) {
-      throw new Error(
-        'FormoAnalytics::chain: account was empty and no previous account has been recorded. You can either pass an account or call connect() first'
-      );
+  private getLocation(): string | undefined {
+    try {
+      const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      return COUNTRY_LIST[timezone as keyof typeof COUNTRY_LIST];
+    } catch (error) {
+      console.error("Error resolving timezone:", error);
+      return undefined;
     }
+  }
 
-    if (isNaN(Number(chainId))) {
-      throw new Error(
-        'FormoAnalytics::chain: chainId must be a valid hex or decimal number'
+  private getLanguage(): string {
+    try {
+      return (
+        (navigator.languages && navigator.languages.length
+          ? navigator.languages[0]
+          : navigator.language) || "en"
       );
+    } catch (error) {
+      console.error("Error resolving language:", error);
+      return "en";
     }
-
-    this.currentChainId = chainId.toString();
-
-    return this.trackEvent(Event.CHAIN_CHANGED, {
-      chainId,
-      account: account || this.currentConnectedAccount,
-    });
-  }
-
-  init(apiKey: string, projectId: string): Promise<FormoAnalytics> {
-    const instance = new FormoAnalytics(apiKey, projectId);
-
-    return Promise.resolve(instance);
   }
 
-  identify(userData: any) {
-    this.identifyUser(userData);
-  }
+  // Adds browser properties to the user-supplied payload
+  private async buildEventPayload(
+    eventSpecificPayload: Record<string, unknown> = {}
+  ): Promise<Record<string, unknown>> {
+    const url = new URL(window.location.href);
+    const params = new URLSearchParams(url.search);
 
-  page() {
-    this.trackPageHit();
-  }
+    const location = this.getLocation();
+    const language = this.getLanguage();
+    const address = await this.getAddress();
 
-  track(eventName: string, eventData: any) {
-    this.trackEvent(eventName, eventData);
-  }
+    // common browser properties
+    return {
+      "user-agent": window.navigator.userAgent,
+      address,
+      locale: language,
+      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,
+    };
+  }  
 }