@formo/analytics 1.17.1 → 1.17.3

package/src/FormoAnalytics.ts

@@ -0,0 +1,1031 @@
+import { createStore, EIP6963ProviderDetail } from "mipd";
+import {
+  EVENTS_API_URL,
+  EventType,
+  LOCAL_ANONYMOUS_ID_KEY,
+  SESSION_CURRENT_URL_KEY,
+  SESSION_USER_ID_KEY,
+  SESSION_WALLET_DETECTED_KEY,
+  TEventType,
+} from "./constants";
+import {
+  cookie,
+  EventManager,
+  EventQueue,
+  IEventManager,
+  initStorageManager,
+  logger,
+  Logger,
+} from "./lib";
+import {
+  Address,
+  ChainID,
+  Config,
+  EIP1193Provider,
+  IFormoAnalytics,
+  IFormoEventContext,
+  IFormoEventProperties,
+  Options,
+  RequestArguments,
+  RPCError,
+  SignatureStatus,
+  TransactionStatus,
+} from "./types";
+import { isAddress, isLocalhost } from "./validators";
+
+export class FormoAnalytics implements IFormoAnalytics {
+  private _provider?: EIP1193Provider;
+  private _providerListeners: Record<string, (...args: unknown[]) => void> = {};
+  private session: FormoAnalyticsSession;
+  private eventManager: IEventManager;
+  private _providers: readonly EIP6963ProviderDetail[] = [];
+
+  config: Config;
+  currentChainId?: ChainID;
+  currentAddress?: Address = "";
+  currentUserId?: string = "";
+
+  private constructor(
+    public readonly writeKey: string,
+    public options: Options = {}
+  ) {
+    this.config = {
+      writeKey,
+      trackLocalhost: options.trackLocalhost || false,
+    };
+
+    this.session = new FormoAnalyticsSession();
+    this.currentUserId =
+      (cookie().get(SESSION_USER_ID_KEY) as string) || undefined;
+
+    this.identify = this.identify.bind(this);
+    this.connect = this.connect.bind(this);
+    this.disconnect = this.disconnect.bind(this);
+    this.chain = this.chain.bind(this);
+    this.signature = this.signature.bind(this);
+    this.transaction = this.transaction.bind(this);
+    this.detect = this.detect.bind(this);
+    this.track = this.track.bind(this);
+
+    // Initialize logger with configuration from options
+    Logger.init({
+      enabled: options.logger?.enabled || false,
+      enabledLevels: options.logger?.levels || [],
+    });
+
+    this.eventManager = new EventManager(
+      new EventQueue(this.config.writeKey, {
+        url: EVENTS_API_URL,
+        flushAt: options.flushAt,
+        retryCount: options.retryCount,
+        maxQueueSize: options.maxQueueSize,
+        flushInterval: options.flushInterval,
+      })
+    );
+
+    // TODO: replace with eip6963
+    const provider = options.provider || window?.ethereum;
+    if (provider) {
+      this.trackProvider(provider);
+    }
+
+    this.trackFirstPageHit();
+    this.trackPageHits();
+  }
+
+  static async init(
+    writeKey: string,
+    options?: Options
+  ): Promise<FormoAnalytics> {
+    initStorageManager(writeKey);
+    const analytics = new FormoAnalytics(writeKey, options);
+
+    // Auto-detect wallet provider
+    analytics._providers = await analytics.getProviders();
+    await analytics.detectWallets(analytics._providers);
+
+    return analytics;
+  }
+
+  /*
+    Public SDK functions
+  */
+
+  /**
+   * Emits a page visit event with the current URL information, fire on page change.
+   * @param {string} category - The category of the page
+   * @param {string} name - The name of the page
+   * @param {Record<string, any>} properties - Additional properties to include
+   * @param {Record<string, any>} context - Additional context to include
+   * @returns {Promise<void>}
+   */
+  public async page(
+    category?: string,
+    name?: string,
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext
+  ): Promise<void> {
+    await this.trackPageHit(category, name, properties, context);
+  }
+
+  /**
+   * Reset the current user session.
+   * @returns {void}
+   */
+  public reset(): void {
+    this.currentUserId = undefined;
+    cookie().remove(LOCAL_ANONYMOUS_ID_KEY);
+    cookie().remove(SESSION_USER_ID_KEY);
+  }
+
+  /**
+   * Emits a connect wallet event.
+   * @param {ChainID} params.chainId
+   * @param {Address} params.address
+   * @param {IFormoEventProperties} properties
+   * @param {IFormoEventContext} context
+   * @param {(...args: unknown[]) => void} callback
+   * @throws {Error} If chainId or address is empty
+   * @returns {Promise<void>}
+   */
+  async connect(
+    {
+      chainId,
+      address,
+    }: {
+      chainId: ChainID;
+      address: Address;
+    },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
+    if (!chainId) {
+      logger.warn("Connect: Chain ID cannot be empty");
+    }
+    if (!address) {
+      logger.warn("Connect: Address cannot be empty");
+    }
+
+    this.currentChainId = chainId;
+    this.currentAddress = address;
+
+    await this.trackEvent(
+      EventType.CONNECT,
+      {
+        chainId,
+        address,
+      },
+      properties,
+      context,
+      callback
+    );
+  }
+
+  /**
+   * Emits a wallet disconnect event.
+   * @param {ChainID} params.chainId
+   * @param {Address} params.address
+   * @param {IFormoEventProperties} properties
+   * @param {IFormoEventContext} context
+   * @param {(...args: unknown[]) => void} callback
+   * @returns {Promise<void>}
+   */
+  async disconnect(
+    params?: {
+      chainId?: ChainID;
+      address?: Address;
+    },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
+    const address = params?.address || this.currentAddress;
+    const chainId = params?.chainId || this.currentChainId;
+
+    await this.handleDisconnect(
+      chainId,
+      address,
+      properties,
+      context,
+      callback
+    );
+  }
+
+  /**
+   * Emits a chain network change event.
+   * @param {ChainID} params.chainId
+   * @param {Address} params.address
+   * @param {IFormoEventProperties} properties
+   * @param {IFormoEventContext} context
+   * @param {(...args: unknown[]) => void} callback
+   * @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>}
+   */
+  async chain(
+    {
+      chainId,
+      address,
+    }: {
+      chainId: ChainID;
+      address?: Address;
+    },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
+    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.currentAddress) {
+      throw new Error(
+        "FormoAnalytics::chain: address was empty and no previous address has been recorded"
+      );
+    }
+
+    this.currentChainId = chainId;
+
+    await this.trackEvent(
+      EventType.CHAIN,
+      {
+        chainId,
+        address: address || this.currentAddress,
+      },
+      properties,
+      context,
+      callback
+    );
+  }
+
+  /**
+   * 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
+   * @param {IFormoEventProperties} properties
+   * @param {IFormoEventContext} context
+   * @param {(...args: unknown[]) => void} callback
+   * @returns {Promise<void>}
+   */
+  async signature(
+    {
+      status,
+      chainId,
+      address,
+      message,
+      signatureHash,
+    }: {
+      status: SignatureStatus;
+      chainId?: ChainID;
+      address: Address;
+      message: string;
+      signatureHash?: string;
+    },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
+    await this.trackEvent(
+      EventType.SIGNATURE,
+      {
+        status,
+        chainId,
+        address,
+        message,
+        ...(signatureHash && { signatureHash }),
+      },
+      properties,
+      context,
+      callback
+    );
+  }
+
+  /**
+   * 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
+   * @param {IFormoEventProperties} properties
+   * @param {IFormoEventContext} context
+   * @param {(...args: unknown[]) => void} callback
+   * @returns {Promise<void>}
+   */
+  async transaction(
+    {
+      status,
+      chainId,
+      address,
+      data,
+      to,
+      value,
+      transactionHash,
+    }: {
+      status: TransactionStatus;
+      chainId: ChainID;
+      address: Address;
+      data?: string;
+      to?: string;
+      value?: string;
+      transactionHash?: string;
+    },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
+    await this.trackEvent(
+      EventType.TRANSACTION,
+      {
+        status,
+        chainId,
+        address,
+        data,
+        to,
+        value,
+        ...(transactionHash && { transactionHash }),
+      },
+      properties,
+      context,
+      callback
+    );
+  }
+
+  /**
+   * Emits an identify event with current wallet address and provider info.
+   * @param {string} params.address
+   * @param {string} params.userId
+   * @param {string} params.rdns
+   * @param {string} params.providerName
+   * @param {IFormoEventProperties} properties
+   * @param {IFormoEventContext} context
+   * @param {(...args: unknown[]) => void} callback
+   * @returns {Promise<void>}
+   */
+  async identify(
+    params?: {
+      address?: Address;
+      providerName?: string;
+      userId?: string;
+      rdns?: string;
+    },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
+    try {
+      if (!params) {
+        // If no params provided, auto-identify
+        logger.info(
+          "Auto-identifying with providers:",
+          this._providers.map((p) => p.info.name)
+        );
+        for (const providerDetail of this._providers) {
+          const provider = providerDetail.provider;
+          if (!provider) continue;
+
+          try {
+            const address = await this.getAddress(provider);
+            if (address) {
+              logger.info(
+                "Auto-identifying",
+                address,
+                providerDetail.info.name,
+                providerDetail.info.rdns
+              );
+              // NOTE: do not set this.currentAddress without explicit connect or identify
+              await this.identify(
+                {
+                  address,
+                  providerName: providerDetail.info.name,
+                  rdns: providerDetail.info.rdns,
+                },
+                properties,
+                context,
+                callback
+              );
+            }
+          } catch (err) {
+            logger.error(
+              `Failed to identify provider ${providerDetail.info.name}:`,
+              err
+            );
+          }
+        }
+        return;
+      }
+
+      // Explicit identify
+      const { userId, address, providerName, rdns } = params;
+      logger.info("Identify", address, userId, providerName, rdns);
+      if (address) this.currentAddress = address;
+      if (userId) {
+        this.currentUserId = userId;
+        cookie().set(SESSION_USER_ID_KEY, userId);
+      }
+
+      await this.trackEvent(
+        EventType.IDENTIFY,
+        {
+          address,
+          providerName,
+          userId,
+          rdns,
+        },
+        properties,
+        context,
+        callback
+      );
+    } catch (e) {
+      logger.log("identify error", e);
+    }
+  }
+
+  /**
+   * Emits a detect wallet event with current wallet provider info.
+   * @param {string} params.providerName
+   * @param {string} params.rdns
+   * @param {IFormoEventProperties} properties
+   * @param {IFormoEventContext} context
+   * @param {(...args: unknown[]) => void} callback
+   * @returns {Promise<void>}
+   */
+  async detect(
+    {
+      providerName,
+      rdns,
+    }: {
+      providerName: string;
+      rdns: string;
+    },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
+    if (this.session.isWalletDetected(rdns))
+      return logger.warn(
+        `Detect: Wallet ${providerName} already detected in this session`
+      );
+
+    this.session.markWalletDetected(rdns);
+    await this.trackEvent(
+      EventType.DETECT,
+      {
+        providerName,
+        rdns,
+      },
+      properties,
+      context,
+      callback
+    );
+  }
+
+  /**
+   * Emits a custom user event with custom properties.
+   * @param {string} event The name of the tracked event
+   * @param {IFormoEventProperties} properties
+   * @param {IFormoEventContext} context
+   * @param {(...args: unknown[]) => void} callback
+   * @returns {Promise<void>}
+   */
+  async track(
+    event: string,
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
+    await this.trackEvent(
+      EventType.TRACK,
+      { event },
+      properties,
+      context,
+      callback
+    );
+  }
+
+  /*
+    SDK tracking and event listener functions
+  */
+
+  private trackProvider(provider: EIP1193Provider): void {
+    try {
+      if (provider === this._provider) {
+        logger.warn("TrackProvider: Provider already tracked.");
+        return;
+      }
+
+      this.currentChainId = undefined;
+      this.currentAddress = undefined;
+
+      if (this._provider) {
+        const actions = Object.keys(this._providerListeners);
+        for (const action of actions) {
+          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();
+    } catch (error) {
+      logger.error("Error tracking provider:", error);
+    }
+  }
+
+  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(): void {
+    const listener = (...args: unknown[]) =>
+      this.onChainChanged(args[0] as string);
+    this.provider?.on("chainChanged", listener);
+    this._providerListeners["chainChanged"] = listener;
+  }
+
+  private registerSignatureListener(): void {
+    if (!this.provider) {
+      logger.error("Provider not found for signature tracking");
+      return;
+    }
+    if (
+      Object.getOwnPropertyDescriptor(this.provider, "request")?.writable ===
+      false
+    ) {
+      logger.warn("Provider.request is not writable");
+      return;
+    }
+
+    const request = this.provider.request.bind(this.provider);
+    this.provider.request = async <T>({
+      method,
+      params,
+    }: RequestArguments): Promise<T | null | undefined> => {
+      if (
+        Array.isArray(params) &&
+        ["eth_signTypedData_v4", "personal_sign"].includes(method)
+      ) {
+        // Emit signature request event
+        this.signature({
+          status: SignatureStatus.REQUESTED,
+          ...this.buildSignatureEventPayload(method, params),
+        });
+
+        try {
+          const response = (await request({ method, params })) as T;
+          if (response) {
+            // Emit signature confirmed event
+            this.signature({
+              status: SignatureStatus.CONFIRMED,
+              ...this.buildSignatureEventPayload(method, params, response),
+            });
+          }
+          return response;
+        } catch (error) {
+          const rpcError = error as RPCError;
+          if (rpcError && rpcError?.code === 4001) {
+            // Emit signature rejected event
+            this.signature({
+              status: SignatureStatus.REJECTED,
+              ...this.buildSignatureEventPayload(method, params),
+            });
+          }
+          throw error;
+        }
+      }
+      return request({ method, params });
+    };
+    return;
+  }
+
+  private registerTransactionListener(): void {
+    if (!this.provider) {
+      logger.error("Provider not found for transaction tracking");
+      return;
+    }
+    if (
+      Object.getOwnPropertyDescriptor(this.provider, "request")?.writable ===
+      false
+    ) {
+      logger.warn("Provider.request is not writable");
+      return;
+    }
+    const request = this.provider.request.bind(this.provider);
+    this.provider.request = async <T>({
+      method,
+      params,
+    }: RequestArguments): Promise<T | null | undefined> => {
+      if (
+        Array.isArray(params) &&
+        method === "eth_sendTransaction" &&
+        params[0]
+      ) {
+        // Track transaction start
+        const payload = await this.buildTransactionEventPayload(params);
+        this.transaction({ status: TransactionStatus.STARTED, ...payload });
+
+        try {
+          // Wait for the transaction hash
+          const transactionHash = (await request({ method, params })) as string;
+
+          // Track transaction broadcast
+          this.transaction({
+            status: TransactionStatus.BROADCASTED,
+            ...payload,
+            transactionHash,
+          });
+
+          return;
+        } catch (error) {
+          logger.error("Transaction error:", error);
+          const rpcError = error as RPCError;
+          if (rpcError && rpcError?.code === 4001) {
+            // Emit transaction rejected event
+            this.transaction({
+              status: TransactionStatus.REJECTED,
+              ...payload,
+            });
+          }
+          throw error;
+        }
+      }
+
+      return request({ method, params });
+    };
+
+    return;
+  }
+
+  private async onAddressChanged(addresses: Address[]): Promise<void> {
+    if (addresses.length > 0) {
+      this.onAddressConnected(addresses[0]);
+    } else {
+      this.onAddressDisconnected();
+    }
+  }
+
+  private async onAddressConnected(address: Address): Promise<void> {
+    if (address === this.currentAddress)
+      // We have already reported this address
+      return;
+
+    this.currentAddress = address;
+
+    this.currentChainId = await this.getCurrentChainId();
+    this.connect({ chainId: this.currentChainId, address });
+  }
+
+  private async handleDisconnect(
+    chainId?: ChainID,
+    address?: Address,
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
+    const payload = {
+      chainId: chainId || this.currentChainId,
+      address: address || this.currentAddress,
+    };
+    this.currentChainId = undefined;
+    this.currentAddress = undefined;
+    cookie().remove(SESSION_USER_ID_KEY);
+
+    await this.trackEvent(
+      EventType.DISCONNECT,
+      payload,
+      properties,
+      context,
+      callback
+    );
+  }
+
+  private async onAddressDisconnected(): Promise<void> {
+    await this.handleDisconnect(this.currentChainId, this.currentAddress);
+  }
+
+  private async onChainChanged(chainIdHex: string): Promise<void> {
+    this.currentChainId = parseInt(chainIdHex);
+    if (!this.currentAddress) {
+      if (!this.provider) {
+        logger.info(
+          "OnChainChanged: Provider not found. CHAIN_CHANGED not reported"
+        );
+        return Promise.resolve();
+      }
+
+      const address = await this.getAddress();
+      if (!address) {
+        logger.info(
+          "OnChainChanged: Unable to fetch or store connected address"
+        );
+        return Promise.resolve();
+      }
+      this.currentAddress = address;
+    }
+
+    // Proceed only if the address exists
+    if (this.currentAddress) {
+      return this.chain({
+        chainId: this.currentChainId,
+        address: this.currentAddress,
+      });
+    } else {
+      logger.info(
+        "OnChainChanged: Current connected address is null despite fetch attempt"
+      );
+    }
+  }
+
+  private async trackFirstPageHit(): Promise<void> {
+    if (cookie().get(SESSION_CURRENT_URL_KEY) === null) {
+      cookie().set(SESSION_CURRENT_URL_KEY, window.location.href);
+    }
+
+    return this.trackPageHit();
+  }
+
+  private async trackPageHits(): Promise<void> {
+    const oldPushState = history.pushState;
+    history.pushState = function pushState(...args) {
+      const ret = oldPushState.apply(this, args);
+      window.dispatchEvent(new window.Event("locationchange"));
+      return ret;
+    };
+
+    const oldReplaceState = history.replaceState;
+    history.replaceState = function replaceState(...args) {
+      const ret = oldReplaceState.apply(this, args);
+      window.dispatchEvent(new window.Event("locationchange"));
+      return ret;
+    };
+
+    window.addEventListener("popstate", () => this.onLocationChange());
+    window.addEventListener("locationchange", () => this.onLocationChange());
+  }
+
+  private async onLocationChange(): Promise<void> {
+    const currentUrl = cookie().get(SESSION_CURRENT_URL_KEY);
+
+    if (currentUrl !== window.location.href) {
+      cookie().set(SESSION_CURRENT_URL_KEY, window.location.href);
+      this.trackPageHit();
+    }
+  }
+
+  private async trackPageHit(
+    category?: string,
+    name?: string,
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
+    if (!this.config.trackLocalhost && isLocalhost()) {
+      return logger.warn(
+        "Track page hit: Ignoring event because website is running locally"
+      );
+    }
+
+    setTimeout(async () => {
+      this.trackEvent(
+        EventType.PAGE,
+        {
+          category,
+          name,
+        },
+        properties,
+        context,
+        callback
+      );
+    }, 300);
+  }
+
+  private async trackEvent(
+    type: TEventType,
+    payload?: any,
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
+    try {
+      this.eventManager.addEvent(
+        {
+          type,
+          ...payload,
+          properties,
+          context,
+          callback,
+        },
+        this.currentAddress,
+        this.currentUserId
+      );
+    } catch (error) {
+      logger.error("Error tracking event:", error);
+    }
+  }
+
+  /*
+    Utility functions
+  */
+
+  private async getProviders(): Promise<readonly EIP6963ProviderDetail[]> {
+    const store = createStore();
+    let providers = store.getProviders();
+    store.subscribe((providerDetails) => {
+      providers = providerDetails;
+      this._providers = providers;
+    });
+
+    // Fallback to injected provider if no providers are found
+    if (providers.length === 0) {
+      this._providers = window?.ethereum ? [window.ethereum] : [];
+      return this._providers;
+    }
+    this._providers = providers;
+    return providers;
+  }
+
+  get providers(): readonly EIP6963ProviderDetail[] {
+    return this._providers;
+  }
+
+  private async detectWallets(
+    providers: readonly EIP6963ProviderDetail[]
+  ): Promise<void> {
+    try {
+      for (const eip6963ProviderDetail of providers) {
+        await this.detect({
+          providerName: eip6963ProviderDetail?.info.name,
+          rdns: eip6963ProviderDetail?.info.rdns,
+        });
+      }
+    } catch (err) {
+      logger.error("Error detect all wallets:", err);
+    }
+  }
+
+  get provider(): EIP1193Provider | undefined {
+    return this._provider;
+  }
+
+  private async getAddress(
+    provider?: EIP1193Provider
+  ): Promise<Address | null> {
+    if (this.currentAddress) return this.currentAddress;
+    const p = provider || this.provider;
+    if (!p) {
+      logger.info("The provider is not set");
+      return null;
+    }
+
+    try {
+      const accounts = await this.getAccounts(p);
+      if (accounts && accounts.length > 0) {
+        if (isAddress(accounts[0])) {
+          return accounts[0];
+        }
+      }
+    } catch (err) {
+      logger.error("Failed to fetch accounts from provider:", err);
+      return null;
+    }
+    return null;
+  }
+
+  private async getAccounts(
+    provider?: EIP1193Provider
+  ): Promise<Address[] | null> {
+    const p = provider || this.provider;
+    try {
+      const res: string[] | null | undefined = await p?.request({
+        method: "eth_accounts",
+      });
+      if (!res || res.length === 0) return null;
+      return res.filter((e) => isAddress(e));
+    } catch (err) {
+      if ((err as any).code !== 4001) {
+        logger.error(
+          "FormoAnalytics::getAccounts: eth_accounts threw an error",
+          err
+        );
+      }
+      return null;
+    }
+  }
+
+  private async getCurrentChainId(): Promise<number> {
+    if (!this.provider) {
+      logger.error("Provider not set for chain ID");
+    }
+
+    let chainIdHex;
+    try {
+      chainIdHex = await this.provider?.request<string>({
+        method: "eth_chainId",
+      });
+      if (!chainIdHex) {
+        logger.info("Chain id not found");
+        return 0;
+      }
+      return parseInt(chainIdHex as string, 16);
+    } catch (err) {
+      logger.error("eth_chainId threw an error:", err);
+      return 0;
+    }
+  }
+
+  private buildSignatureEventPayload(
+    method: string,
+    params: unknown[],
+    response?: unknown
+  ) {
+    const basePayload = {
+      chainId: this.currentChainId,
+      address:
+        method === "personal_sign"
+          ? (params[1] as Address)
+          : (params[0] as Address),
+    };
+
+    if (method === "personal_sign") {
+      const message = Buffer.from(
+        (params[0] as string).slice(2),
+        "hex"
+      ).toString("utf8");
+      return {
+        ...basePayload,
+        message,
+        ...(response ? { signatureHash: response as string } : {}),
+      };
+    }
+
+    return {
+      ...basePayload,
+      message: params[1] as string,
+      ...(response ? { signatureHash: response as string } : {}),
+    };
+  }
+
+  private async buildTransactionEventPayload(params: unknown[]) {
+    const { data, from, to, value } = params[0] as {
+      data: string;
+      from: string;
+      to: string;
+      value: string;
+    };
+    return {
+      chainId: this.currentChainId || (await this.getCurrentChainId()),
+      data,
+      address: from,
+      to,
+      value,
+    };
+  }
+}
+
+interface IFormoAnalyticsSession {
+  isWalletDetected(rdns: string): boolean;
+  markWalletDetected(rdns: string): void;
+}
+
+class FormoAnalyticsSession implements IFormoAnalyticsSession {
+  public isWalletDetected(rdns: string): boolean {
+    const rdnses = cookie().get(SESSION_WALLET_DETECTED_KEY)?.split(",") || [];
+    return rdnses.includes(rdns);
+  }
+
+  public markWalletDetected(rdns: string): void {
+    const rdnses = cookie().get(SESSION_WALLET_DETECTED_KEY)?.split(",") || [];
+    rdnses.push(rdns);
+    cookie().set(SESSION_WALLET_DETECTED_KEY, rdnses.join(","), {
+      // by the end of the day
+      expires: new Date(Date.now() + 86400 * 1000).toUTCString(),
+      path: "/",
+    });
+  }
+}