0xtrails 0.13.2 → 0.14.0

package/src/widget/hooks/useCheckout.ts

@@ -1,361 +0,0 @@
-import { useCallback, useRef } from "react"
-import { SECOND_MS } from "../../utils/time.js"
-import { getSessionId } from "../../analytics.js"
-import { logger } from "../../logger.js"
-import {
-  updatePersistentToast,
-  showToast,
-  removePersistentToast,
-} from "../../toast.js"
-import {
-  getPrettifiedErrorMessage,
-  getIsUserRejectionError,
-  UserRejectionError,
-  getErrorString,
-} from "../../error.js"
-import type { TransactionState } from "../../transactions.js"
-import type { PrepareSendQuote } from "../../transactionIntent/types.js"
-
-export type CheckoutCallbacks = {
-  onCheckoutStart?: (data: { sessionId: string }) => void
-  onCheckoutQuote?: (data: {
-    sessionId: string
-    quote: PrepareSendQuote
-  }) => void
-  onCheckoutSignatureRequest?: (data: { sessionId: string }) => void
-  onCheckoutSignatureConfirmed?: (data: { sessionId: string }) => void
-  onCheckoutSignatureRejected?: (data: {
-    sessionId: string
-    error: unknown
-  }) => void
-  onCheckoutApprovalRequest?: (data: { sessionId: string }) => void
-  onCheckoutApprovalConfirmed?: (data: {
-    sessionId: string
-    transactionHash: `0x${string}`
-  }) => void
-  onCheckoutApprovalRejected?: (data: {
-    sessionId: string
-    error: unknown
-  }) => void
-  onCheckoutComplete?: (data: { sessionId: string }) => void
-  onCheckoutError?: (data: {
-    sessionId: string
-    error: string | UserRejectionError
-  }) => void
-  onCheckoutStatusUpdate?: (data: {
-    sessionId: string
-    transactionStates: TransactionState[]
-  }) => void
-}
-
-export type CheckoutOnHandlers = {
-  /** Triggered when the intent transaction process starts. */
-  triggerCheckoutStart: () => void
-  /** Triggered when a quote is received. */
-  triggerCheckoutQuote: (quote: PrepareSendQuote) => void
-  /** Triggered when a signature is requested. */
-  triggerCheckoutSignatureRequest: () => void
-  /** Triggered when a signature is confirmed. */
-  triggerCheckoutSignatureConfirmed: () => void
-  /** Triggered when a signature is rejected. */
-  triggerCheckoutSignatureRejected: (error: unknown) => void
-  /** Triggered when a token approval is requested. */
-  triggerCheckoutApprovalRequest: () => void
-  /** Triggered when a token approval is confirmed. */
-  triggerCheckoutApprovalConfirmed: (transactionHash: `0x${string}`) => void
-  /** Triggered when a token approval is rejected. */
-  triggerCheckoutApprovalRejected: (error: unknown) => void
-  /** Triggered when the intent transaction process completes. */
-  triggerCheckoutComplete: (
-    txStatus: "success" | "fail",
-    accountAddress?: string,
-  ) => void
-  /** Triggered when an error occurs. */
-  triggerCheckoutError: (error: string) => void
-  /** Triggered when the intent transaction states change. */
-  triggerCheckoutStatusUpdate: (transactionStates: TransactionState[]) => void
-}
-
-export type UseCheckoutProps = CheckoutCallbacks
-
-export type UseCheckoutReturn = {
-  sessionId: string
-  startCheckout: () => void
-  checkoutOnHandlers: CheckoutOnHandlers
-}
-
-/**
- * Hook to manage checkout session state and callback handlers
- * Tracks session ID and provides methods to trigger checkout callbacks
- */
-export function useCheckout({
-  onCheckoutStart,
-  onCheckoutQuote,
-  onCheckoutSignatureRequest,
-  onCheckoutSignatureConfirmed,
-  onCheckoutSignatureRejected,
-  onCheckoutApprovalRequest,
-  onCheckoutApprovalConfirmed,
-  onCheckoutApprovalRejected,
-  onCheckoutComplete,
-  onCheckoutError,
-  onCheckoutStatusUpdate,
-}: UseCheckoutProps): UseCheckoutReturn {
-  const sessionIdRef = useRef<string>(getSessionId())
-
-  const startCheckout = useCallback(() => {
-    sessionIdRef.current = getSessionId()
-  }, [])
-
-  const triggerCheckoutStart = useCallback(() => {
-    if (onCheckoutStart && sessionIdRef.current) {
-      try {
-        onCheckoutStart({
-          sessionId: sessionIdRef.current,
-        })
-      } catch (error) {
-        logger.console.error(
-          "[trails-sdk] Error calling onCheckoutStart:",
-          error,
-        )
-      }
-    }
-  }, [onCheckoutStart])
-
-  const triggerCheckoutQuote = useCallback(
-    (quote: PrepareSendQuote) => {
-      if (onCheckoutQuote && sessionIdRef.current) {
-        try {
-          onCheckoutQuote({
-            sessionId: sessionIdRef.current,
-            quote,
-          })
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error calling onCheckoutQuote:",
-            error,
-          )
-        }
-      }
-    },
-    [onCheckoutQuote],
-  )
-
-  const triggerCheckoutSignatureRequest = useCallback(() => {
-    if (onCheckoutSignatureRequest && sessionIdRef.current) {
-      try {
-        onCheckoutSignatureRequest({
-          sessionId: sessionIdRef.current,
-        })
-      } catch (error) {
-        logger.console.error(
-          "[trails-sdk] Error calling onCheckoutSignatureRequest:",
-          error,
-        )
-      }
-    }
-  }, [onCheckoutSignatureRequest])
-
-  const triggerCheckoutSignatureConfirmed = useCallback(() => {
-    if (onCheckoutSignatureConfirmed && sessionIdRef.current) {
-      try {
-        onCheckoutSignatureConfirmed({
-          sessionId: sessionIdRef.current,
-        })
-      } catch (error) {
-        logger.console.error(
-          "[trails-sdk] Error calling onCheckoutSignatureConfirmed:",
-          error,
-        )
-      }
-    }
-  }, [onCheckoutSignatureConfirmed])
-
-  const triggerCheckoutSignatureRejected = useCallback(
-    (error: unknown) => {
-      if (onCheckoutSignatureRejected && sessionIdRef.current) {
-        try {
-          onCheckoutSignatureRejected({
-            sessionId: sessionIdRef.current,
-            error,
-          })
-        } catch (callbackError) {
-          logger.console.error(
-            "[trails-sdk] Error calling onCheckoutSignatureRejected:",
-            callbackError,
-          )
-        }
-      }
-    },
-    [onCheckoutSignatureRejected],
-  )
-
-  const triggerCheckoutApprovalRequest = useCallback(() => {
-    if (onCheckoutApprovalRequest && sessionIdRef.current) {
-      try {
-        onCheckoutApprovalRequest({
-          sessionId: sessionIdRef.current,
-        })
-      } catch (error) {
-        logger.console.error(
-          "[trails-sdk] Error calling onCheckoutApprovalRequest:",
-          error,
-        )
-      }
-    }
-  }, [onCheckoutApprovalRequest])
-
-  const triggerCheckoutApprovalConfirmed = useCallback(
-    (transactionHash: `0x${string}`) => {
-      if (onCheckoutApprovalConfirmed && sessionIdRef.current) {
-        try {
-          onCheckoutApprovalConfirmed({
-            sessionId: sessionIdRef.current,
-            transactionHash,
-          })
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error calling onCheckoutApprovalConfirmed:",
-            error,
-          )
-        }
-      }
-    },
-    [onCheckoutApprovalConfirmed],
-  )
-
-  const triggerCheckoutApprovalRejected = useCallback(
-    (error: unknown) => {
-      if (onCheckoutApprovalRejected && sessionIdRef.current) {
-        try {
-          onCheckoutApprovalRejected({
-            sessionId: sessionIdRef.current,
-            error,
-          })
-        } catch (callbackError) {
-          logger.console.error(
-            "[trails-sdk] Error calling onCheckoutApprovalRejected:",
-            callbackError,
-          )
-        }
-      }
-    },
-    [onCheckoutApprovalRejected],
-  )
-
-  const triggerCheckoutComplete = useCallback(
-    (txStatus: "success" | "fail", _accountAddress?: string) => {
-      if (onCheckoutComplete && sessionIdRef.current) {
-        try {
-          onCheckoutComplete({
-            sessionId: sessionIdRef.current,
-          })
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error calling onCheckoutComplete:",
-            error,
-          )
-        }
-      }
-
-      if (txStatus === "success") {
-        // Dismiss any persistent toast before showing success toast
-        removePersistentToast()
-
-        showToast(
-          "Transaction Complete",
-          "Your transaction has been successfully processed",
-          "success",
-          5 * SECOND_MS, // 5 seconds
-        )
-      } else {
-        // Default to error for any non-success status (including 'fail' and any unexpected values)
-        updatePersistentToast(
-          "Transaction Failed",
-          "Your transaction failed or was refunded",
-          "error",
-        )
-      }
-    },
-    [onCheckoutComplete],
-  )
-
-  const triggerCheckoutError = useCallback(
-    (error: string) => {
-      // Wrap user rejection errors in custom UserRejectionError class
-      let processedError: string | UserRejectionError = error
-      const isUserRejection = getIsUserRejectionError(error)
-
-      if (isUserRejection) {
-        const errorMessage = getErrorString(error)
-        processedError = new UserRejectionError(errorMessage)
-
-        // Trigger signature rejected callback for user rejections
-        triggerCheckoutSignatureRejected(processedError)
-      }
-
-      if (onCheckoutError && sessionIdRef.current) {
-        try {
-          onCheckoutError({
-            sessionId: sessionIdRef.current,
-            error: processedError,
-          })
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error calling onCheckoutError:",
-            error,
-          )
-        }
-      }
-
-      updatePersistentToast(
-        "Transaction Failed",
-        getPrettifiedErrorMessage(
-          processedError,
-          "An error occurred while processing your transaction",
-        ),
-        "error",
-      )
-    },
-    [onCheckoutError, triggerCheckoutSignatureRejected],
-  )
-
-  const triggerCheckoutStatusUpdate = useCallback(
-    (transactionStates: TransactionState[]) => {
-      if (onCheckoutStatusUpdate && sessionIdRef.current) {
-        try {
-          onCheckoutStatusUpdate({
-            sessionId: sessionIdRef.current,
-            transactionStates,
-          })
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error calling onCheckoutStatusUpdate:",
-            error,
-          )
-        }
-      }
-    },
-    [onCheckoutStatusUpdate],
-  )
-
-  const result = {
-    sessionId: sessionIdRef.current,
-    startCheckout,
-    checkoutOnHandlers: {
-      triggerCheckoutStart,
-      triggerCheckoutQuote,
-      triggerCheckoutSignatureRequest,
-      triggerCheckoutSignatureConfirmed,
-      triggerCheckoutSignatureRejected,
-      triggerCheckoutApprovalRequest,
-      triggerCheckoutApprovalConfirmed,
-      triggerCheckoutApprovalRejected,
-      triggerCheckoutComplete,
-      triggerCheckoutError,
-      triggerCheckoutStatusUpdate,
-    },
-  }
-
-  return result
-}

package/src/widget/hooks/useClickTracking.ts

@@ -1,74 +0,0 @@
-import { useCallback, useRef } from "react"
-import { trackWidgetClick } from "../../analytics.js"
-import { logger } from "../../logger.js"
-import { useViewManager } from "./useViewManager.js"
-
-export interface ClickTrackingOptions {
-  component?: string
-  action?: string
-  label?: string
-  value?: string | number
-  metadata?: Record<string, any>
-  debounceMs?: number
-}
-
-export function useClickTracking() {
-  const { screen } = useViewManager()
-  const screenRef = useRef(screen)
-  screenRef.current = screen
-  const lastClickRef = useRef<{ [key: string]: number }>({})
-
-  const trackClick = useCallback((options: ClickTrackingOptions = {}) => {
-    const {
-      component = "unknown",
-      action = "click",
-      label,
-      value,
-      metadata,
-      debounceMs = 300,
-    } = options
-
-    const clickKey = `${component}-${action}-${label || ""}`
-    const now = Date.now()
-    const lastClick = lastClickRef.current[clickKey] || 0
-
-    // Debounce rapid clicks
-    if (debounceMs > 0 && now - lastClick < debounceMs) {
-      logger.console.debug("Click debounced:", clickKey)
-      return
-    }
-
-    lastClickRef.current[clickKey] = now
-
-    // Convert all metadata values to strings
-    const stringMetadata: Record<string, string> = {}
-    if (metadata) {
-      for (const [key, val] of Object.entries(metadata)) {
-        stringMetadata[key] = val?.toString() || ""
-      }
-    }
-
-    // Track the click event - ensure all values are strings
-    trackWidgetClick({
-      screen: screenRef.current,
-      component: component?.toString() || "unknown",
-      action: action?.toString() || "click",
-      label: label?.toString(),
-      value: value?.toString(),
-      ...stringMetadata,
-      timestamp: now.toString(),
-    })
-
-    logger.console.debug("Click tracked:", {
-      component,
-      action,
-      label,
-      value,
-      metadata,
-    })
-  }, [])
-
-  return {
-    trackClick,
-  }
-}