@formo/analytics 1.16.3 → 1.16.5

package/src/FormoAnalytics.ts

@@ -1,17 +1,17 @@
-import { UUID } from "crypto";
 import { createStore, EIP6963ProviderDetail } from "mipd";
 import {
-  Event,
   EVENTS_API_URL,
+  EventType,
   LOCAL_ANONYMOUS_ID_KEY,
   SESSION_CURRENT_URL_KEY,
   SESSION_USER_ID_KEY,
   SESSION_WALLET_DETECTED_KEY,
+  TEventType,
 } from "./constants";
 import {
-  EventFactory,
+  EventManager,
   EventQueue,
-  IEventFactory,
+  IEventManager,
   local,
   logger,
   Logger,
@@ -22,62 +22,104 @@ import {
   ChainID,
   Config,
   EIP1193Provider,
+  IFormoEventContext,
+  IFormoEventProperties,
   Options,
   RequestArguments,
   RPCError,
   SignatureStatus,
   TransactionStatus,
 } from "./types";
-import { generateNativeUUID } from "./utils";
-import { isAddress, isArray, isLocalhost } from "./validators";
+import { isAddress, isLocalhost } from "./validators";
 
 interface IFormoAnalytics {
-  page(): void;
+  page(
+    category?: string,
+    name?: string,
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): void;
   reset(): void;
-  connect(params: { chainId: ChainID; address: Address }): Promise<void>;
-  disconnect(params?: { chainId?: ChainID; address?: Address }): Promise<void>;
-  chain(params: { chainId: ChainID; address?: Address }): Promise<void>;
-  signature(params: {
-    status: SignatureStatus;
-    chainId?: ChainID;
-    address: Address;
-    message: string;
-    signatureHash?: string;
-  }): Promise<void>;
-  transaction(params: {
-    status: TransactionStatus;
-    chainId: ChainID;
-    address: Address;
-    data?: string;
-    to?: string;
-    value?: string;
-    transactionHash?: string;
-  }): Promise<void>;
+  detect(
+    params: { rdns: string; providerName: string },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void>;
+  connect(
+    params: { chainId: ChainID; address: Address },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void>;
+  disconnect(
+    params?: { chainId?: ChainID; address?: Address },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void>;
+  chain(
+    params: { chainId: ChainID; address?: Address },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void>;
+  signature(
+    params: {
+      status: SignatureStatus;
+      chainId?: ChainID;
+      address: Address;
+      message: string;
+      signatureHash?: string;
+    },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void>;
+  transaction(
+    params: {
+      status: TransactionStatus;
+      chainId: ChainID;
+      address: Address;
+      data?: string;
+      to?: string;
+      value?: string;
+      transactionHash?: string;
+    },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void>;
   identify(
-    params?:
-      | {
-          address: Address | null;
-          providerName?: string;
-          userId?: string;
-          rdns?: string;
-        }
-      | readonly EIP6963ProviderDetail[]
+    params: {
+      address: Address;
+      providerName?: string;
+      userId?: string;
+      rdns?: string;
+    },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void>;
+  track(
+    event: string,
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
   ): Promise<void>;
-  track(action: string, payload: Record<string, any>): Promise<void>;
 }
 
 export class FormoAnalytics implements IFormoAnalytics {
   private _provider?: EIP1193Provider;
   private _providerListeners: Record<string, (...args: unknown[]) => void> = {};
   private session: FormoAnalyticsSession;
-  private eventQueue: EventQueue;
-  private anonymousId: UUID | null = null;
-  private userId: string | null = null;
-  private eventFactory: IEventFactory;
+  private eventManager: IEventManager;
 
   config: Config;
   currentChainId?: ChainID;
-  currentConnectedAddress?: Address;
+  currentAddress?: Address;
+  currentUserId?: string;
 
   private constructor(
     public readonly writeKey: string,
@@ -89,6 +131,8 @@ export class FormoAnalytics implements IFormoAnalytics {
     };
 
     this.session = new FormoAnalyticsSession();
+    this.currentUserId =
+      (session.get(SESSION_USER_ID_KEY) as string) || undefined;
 
     // Initialize logger with configuration from options
     Logger.init({
@@ -96,18 +140,15 @@ export class FormoAnalytics implements IFormoAnalytics {
       enabledLevels: options.logger?.levels || [],
     });
 
-    this.eventFactory = new EventFactory();
-
-    this.eventQueue = new EventQueue(this.config.writeKey, {
-      url: EVENTS_API_URL,
-      flushAt: options.flushAt,
-      retryCount: options.retryCount,
-      maxQueueSize: options.maxQueueSize,
-      flushInterval: options.flushInterval,
-    });
-
-    this.anonymousId = this.getAnonymousId();
-    this.userId = session.get(SESSION_USER_ID_KEY) as string | null;
+    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;
@@ -125,9 +166,9 @@ export class FormoAnalytics implements IFormoAnalytics {
   ): Promise<FormoAnalytics> {
     const analytics = new FormoAnalytics(writeKey, options);
 
-    // Detect
+    // Auto-detect wallet provider
     const providers = await analytics.getProviders();
-    await analytics.detects(providers);
+    await analytics.detectWallets(providers);
 
     return analytics;
   }
@@ -138,10 +179,19 @@ export class FormoAnalytics implements IFormoAnalytics {
 
   /**
    * 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(): Promise<void> {
-    await this.trackPageHit();
+  public async page(
+    category?: string,
+    name?: string,
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext
+  ): Promise<void> {
+    await this.trackPageHit(category, name, properties, context);
   }
 
   /**
@@ -149,26 +199,33 @@ export class FormoAnalytics implements IFormoAnalytics {
    * @returns {void}
    */
   public reset(): void {
-    this.anonymousId = this.getAnonymousId();
-    this.userId = null;
+    this.currentUserId = undefined;
     local.remove(LOCAL_ANONYMOUS_ID_KEY);
     session.remove(SESSION_USER_ID_KEY);
   }
 
   /**
-   * Emits a wallet connect event.
+   * 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;
-  }): 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");
     }
@@ -177,45 +234,73 @@ export class FormoAnalytics implements IFormoAnalytics {
     }
 
     this.currentChainId = chainId;
-    this.currentConnectedAddress = address;
+    this.currentAddress = address;
 
-    await this.trackEvent(Event.CONNECT, {
-      chainId,
-      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;
-  }): Promise<void> {
-    const address = params?.address || this.currentConnectedAddress;
+  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);
+    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;
-  }): 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");
     }
@@ -224,7 +309,7 @@ export class FormoAnalytics implements IFormoAnalytics {
         "FormoAnalytics::chain: chainId must be a valid decimal number"
       );
     }
-    if (!address && !this.currentConnectedAddress) {
+    if (!address && !this.currentAddress) {
       throw new Error(
         "FormoAnalytics::chain: address was empty and no previous address has been recorded"
       );
@@ -232,10 +317,16 @@ export class FormoAnalytics implements IFormoAnalytics {
 
     this.currentChainId = chainId;
 
-    await this.trackEvent(Event.CHAIN_CHANGED, {
-      chainId,
-      address: address || this.currentConnectedAddress,
-    });
+    await this.trackEvent(
+      EventType.CHAIN,
+      {
+        chainId,
+        address: address || this.currentAddress,
+      },
+      properties,
+      context,
+      callback
+    );
   }
 
   /**
@@ -245,28 +336,42 @@ export class FormoAnalytics implements IFormoAnalytics {
    * @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;
-  }): Promise<void> {
-    await this.trackEvent(Event.SIGNATURE, {
+  async signature(
+    {
       status,
       chainId,
       address,
       message,
-      ...(signatureHash && { signatureHash }),
-    });
+      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
+    );
   }
 
   /**
@@ -278,132 +383,154 @@ export class FormoAnalytics implements IFormoAnalytics {
    * @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;
-  }): Promise<void> {
-    await this.trackEvent(Event.TRANSACTION, {
+  async transaction(
+    {
       status,
       chainId,
       address,
       data,
       to,
       value,
-      ...(transactionHash && { transactionHash }),
-    });
+      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 detect event with current wallet provider info.
+   * Emits an identify event with current wallet address and provider info.
    * @param {string} params.providerName
    * @param {string} params.rdns
    * @param {string} params.userId
    * @param {string} params.address
-   *
+   * @param {IFormoEventProperties} properties
+   * @param {IFormoEventContext} context
+   * @param {(...args: unknown[]) => void} callback
    * @returns {Promise<void>}
    */
   public async identify(
-    params?:
-      | {
-          address: Address | null;
-          providerName?: string;
-          userId?: string;
-          rdns?: string;
-        }
-      | readonly EIP6963ProviderDetail[]
+    params: {
+      address?: Address;
+      providerName?: string;
+      userId?: string;
+      rdns?: string;
+    },
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
   ): Promise<void> {
-    if (isArray(params) || !params) {
-      const providers = isArray(params) ? params : await this.getProviders();
-      try {
-        for (const eip6963ProviderDetail of providers) {
-          if (!eip6963ProviderDetail) continue;
-          const accounts = await this.getAccounts(
-            eip6963ProviderDetail?.provider
-          );
-          // Identify with accounts
-          if (accounts && accounts.length > 0) {
-            for (const address of accounts) {
-              await this.identify({
-                address,
-                providerName: eip6963ProviderDetail?.info.name,
-                rdns: eip6963ProviderDetail?.info.rdns,
-              });
-            }
-          } else {
-            // Identify without accounts
-            await this.identify({
-              address: null,
-              providerName: eip6963ProviderDetail?.info.name,
-              rdns: eip6963ProviderDetail?.info.rdns,
-            });
-          }
-        }
-      } catch (err) {
-        logger.error("Error identifying all:", err);
-      }
-    } else {
-      const { userId, address, providerName, rdns } = params as {
-        address: Address | null;
-        providerName?: string;
-        userId?: string;
-        rdns?: string;
-      };
-      if (userId) this.userId = userId || null;
-      await this.trackEvent(Event.IDENTIFY, {
+    const { userId, address, providerName, rdns } = params;
+
+    this.currentAddress = address;
+    if (userId) {
+      this.currentUserId = userId;
+      session.set(SESSION_USER_ID_KEY, userId);
+    }
+
+    await this.trackEvent(
+      EventType.IDENTIFY,
+      {
         address,
         providerName,
+        userId,
         rdns,
-      });
-    }
+      },
+      properties,
+      context,
+      callback
+    );
   }
 
   /**
-   * Emits an identify event with current wallet address.
-   * @param {Address} params.address
+   * 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>}
    */
-  private async detect({
-    providerName,
-    rdns,
-  }: {
-    providerName: string;
-    rdns: string;
-  }): 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`
+        `Detect: Wallet ${providerName} already detected in this session`
       );
 
-    this.session.markWalletdetected(rdns);
-    await this.trackEvent(Event.DETECT_WALLET, {
-      providerName,
-      rdns,
-    });
+    this.session.markWalletDetected(rdns);
+    await this.trackEvent(
+      EventType.DETECT,
+      {
+        providerName,
+        rdns,
+      },
+      properties,
+      context,
+      callback
+    );
   }
 
   /**
-   * Emits a custom event with custom data.
-   * @param {string} action
-   * @param {Record<string, any>} payload
+   * 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(action: string, payload: Record<string, any>): Promise<void> {
-    await this.trackEvent(action, payload);
+  async track(
+    event: EventType,
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
+    await this.trackEvent(
+      EventType.TRACK,
+      { event },
+      properties,
+      context,
+      callback
+    );
   }
 
   /*
@@ -418,7 +545,7 @@ export class FormoAnalytics implements IFormoAnalytics {
       }
 
       this.currentChainId = undefined;
-      this.currentConnectedAddress = undefined;
+      this.currentAddress = undefined;
 
       if (this._provider) {
         const actions = Object.keys(this._providerListeners);
@@ -584,11 +711,11 @@ export class FormoAnalytics implements IFormoAnalytics {
   }
 
   private async onAddressConnected(address: Address): Promise<void> {
-    if (address === this.currentConnectedAddress)
+    if (address === this.currentAddress)
       // We have already reported this address
       return;
 
-    this.currentConnectedAddress = address;
+    this.currentAddress = address;
 
     this.currentChainId = await this.getCurrentChainId();
     this.connect({ chainId: this.currentChainId, address });
@@ -596,29 +723,35 @@ export class FormoAnalytics implements IFormoAnalytics {
 
   private async handleDisconnect(
     chainId?: ChainID,
-    address?: Address
+    address?: Address,
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
   ): Promise<void> {
     const payload = {
-      chain_id: chainId || this.currentChainId,
-      address: address || this.currentConnectedAddress,
+      chainId: chainId || this.currentChainId,
+      address: address || this.currentAddress,
     };
     this.currentChainId = undefined;
-    this.currentConnectedAddress = undefined;
+    this.currentAddress = undefined;
     session.remove(SESSION_USER_ID_KEY);
 
-    await this.trackEvent(Event.DISCONNECT, payload);
+    await this.trackEvent(
+      EventType.DISCONNECT,
+      payload,
+      properties,
+      context,
+      callback
+    );
   }
 
   private async onAddressDisconnected(): Promise<void> {
-    await this.handleDisconnect(
-      this.currentChainId,
-      this.currentConnectedAddress
-    );
+    await this.handleDisconnect(this.currentChainId, this.currentAddress);
   }
 
   private async onChainChanged(chainIdHex: string): Promise<void> {
     this.currentChainId = parseInt(chainIdHex);
-    if (!this.currentConnectedAddress) {
+    if (!this.currentAddress) {
       if (!this.provider) {
         logger.info(
           "OnChainChanged: Provider not found. CHAIN_CHANGED not reported"
@@ -633,14 +766,14 @@ export class FormoAnalytics implements IFormoAnalytics {
         );
         return Promise.resolve();
       }
-      this.currentConnectedAddress = address;
+      this.currentAddress = address;
     }
 
     // Proceed only if the address exists
-    if (this.currentConnectedAddress) {
+    if (this.currentAddress) {
       return this.chain({
         chainId: this.currentChainId,
-        address: this.currentConnectedAddress,
+        address: this.currentAddress,
       });
     } else {
       logger.info(
@@ -685,7 +818,13 @@ export class FormoAnalytics implements IFormoAnalytics {
     }
   }
 
-  private trackPageHit(): void {
+  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"
@@ -693,30 +832,38 @@ export class FormoAnalytics implements IFormoAnalytics {
     }
 
     setTimeout(async () => {
-      this.trackEvent(Event.PAGE);
+      this.trackEvent(
+        EventType.PAGE,
+        {
+          category,
+          name,
+        },
+        properties,
+        context,
+        callback
+      );
     }, 300);
   }
 
-  private async trackEvent(action: string, payload?: any): Promise<void> {
+  private async trackEvent(
+    type: TEventType,
+    payload?: any,
+    properties?: IFormoEventProperties,
+    context?: IFormoEventContext,
+    callback?: (...args: unknown[]) => void
+  ): Promise<void> {
     try {
-      const address = await this.getAddress();
-      const user_id = this.userId;
-
-      const requestData = this.eventFactory.create(
-        this.anonymousId as UUID,
-        user_id,
-        address,
+      this.eventManager.addEvent(
         {
-          action,
+          type,
           ...payload,
-        }
+          properties,
+          context,
+          callback,
+        },
+        this.currentAddress,
+        this.currentUserId
       );
-
-      await this.eventQueue.enqueue(requestData, (err, _, data) => {
-        if (err) {
-          logger.error("Error sending events:", err);
-        } else logger.info(`Events sent successfully: ${data.length} events`);
-      });
     } catch (error) {
       logger.error("Error tracking event:", error);
     }
@@ -739,7 +886,7 @@ export class FormoAnalytics implements IFormoAnalytics {
     return providers;
   }
 
-  private async detects(
+  private async detectWallets(
     providers: readonly EIP6963ProviderDetail[]
   ): Promise<void> {
     try {
@@ -758,17 +905,8 @@ export class FormoAnalytics implements IFormoAnalytics {
     return this._provider;
   }
 
-  private getAnonymousId(): UUID {
-    const storedAnonymousId = local.get(LOCAL_ANONYMOUS_ID_KEY);
-    if (storedAnonymousId && typeof storedAnonymousId === "string")
-      return storedAnonymousId as UUID;
-    const newAnonymousId = generateNativeUUID();
-    local.set(LOCAL_ANONYMOUS_ID_KEY, newAnonymousId);
-    return newAnonymousId;
-  }
-
   private async getAddress(): Promise<Address | null> {
-    if (this.currentConnectedAddress) return this.currentConnectedAddress;
+    if (this.currentAddress) return this.currentAddress;
     if (!this?.provider) {
       logger.info("The provider is not set");
       return null;
@@ -881,7 +1019,7 @@ export class FormoAnalytics implements IFormoAnalytics {
 
 interface IFormoAnalyticsSession {
   isWalletDetected(rdns: string): boolean;
-  markWalletdetected(rdns: string): void;
+  markWalletDetected(rdns: string): void;
 }
 
 class FormoAnalyticsSession implements IFormoAnalyticsSession {
@@ -892,7 +1030,7 @@ class FormoAnalyticsSession implements IFormoAnalyticsSession {
     return rdnses.includes(rdns);
   }
 
-  public markWalletdetected(rdns: string): void {
+  public markWalletDetected(rdns: string): void {
     const rdnses = (session.get(SESSION_WALLET_DETECTED_KEY) as string[]) || [];
     rdnses.push(rdns);
     session.set(SESSION_WALLET_DETECTED_KEY, rdnses);