0xtrails 0.12.2 → 0.13.0

package/src/widget/hooks/useMode.tsx

@@ -1,51 +0,0 @@
-import { createContext, useContext, useEffect, useState } from "react"
-import type { ReactNode } from "react"
-import type { Mode } from "../../mode.js"
-
-interface ModeContextType {
-  /** The effective mode — use this for all UI decisions */
-  mode: Mode
-  /** The mode from the widget prop (source of truth) */
-  configuredMode: Mode
-  /** Temporarily override the mode (e.g. "Buy Crypto" from settings) */
-  setMode: (mode: Mode) => void
-  /** Clear any override, reverting to configuredMode */
-  resetMode: () => void
-}
-
-const ModeContext = createContext<ModeContextType | null>(null)
-
-interface ModeProviderProps {
-  children: ReactNode
-  configuredMode: Mode
-}
-
-export function ModeProvider({ children, configuredMode }: ModeProviderProps) {
-  const [overrideMode, setOverrideMode] = useState<Mode | null>(null)
-
-  // biome-ignore lint/correctness/useExhaustiveDependencies: intentionally reacts to configuredMode changes to clear internal overrides
-  useEffect(() => {
-    setOverrideMode(null)
-  }, [configuredMode])
-
-  return (
-    <ModeContext.Provider
-      value={{
-        mode: overrideMode ?? configuredMode,
-        configuredMode,
-        setMode: (m: Mode) => setOverrideMode(m),
-        resetMode: () => setOverrideMode(null),
-      }}
-    >
-      {children}
-    </ModeContext.Provider>
-  )
-}
-
-export function useMode(): ModeContextType {
-  const context = useContext(ModeContext)
-  if (!context) {
-    throw new Error("useMode must be used within a ModeProvider")
-  }
-  return context
-}

package/src/widget/hooks/usePreviousScreen.ts

@@ -1,36 +0,0 @@
-import React, {
-  createContext,
-  useContext,
-  useState,
-  type ReactNode,
-} from "react"
-import type { Screen } from "./useCurrentScreen.js"
-
-interface PreviousScreenContextType {
-  previousScreen: Screen | null
-  setPreviousScreen: (screen: Screen | null) => void
-}
-
-const PreviousScreenContext = createContext<PreviousScreenContextType | null>(
-  null,
-)
-
-export function PreviousScreenProvider({ children }: { children: ReactNode }) {
-  const [previousScreen, setPreviousScreen] = useState<Screen | null>(null)
-
-  return React.createElement(
-    PreviousScreenContext.Provider,
-    { value: { previousScreen, setPreviousScreen } },
-    children,
-  )
-}
-
-export function usePreviousScreen(): PreviousScreenContextType {
-  const context = useContext(PreviousScreenContext)
-  if (!context) {
-    throw new Error(
-      "usePreviousScreen must be used within a PreviousScreenProvider",
-    )
-  }
-  return context
-}

package/src/widget/workers/intentExecutionWorker.ts

@@ -1,502 +0,0 @@
-import { logger } from "../../logger.js"
-import { getIntent, executeIntent } from "../../intents.js"
-import { trackDepositResilient } from "../../transactionIntent/utils/resilientDepositTracker.js"
-import type { TrailsClient } from "../../trailsClient.js"
-import { getChainRpcClient } from "../../chains.js"
-import { IntentStatus } from "@0xtrails/api"
-import { SECOND_MS, HOUR_MS } from "../../utils/time.js"
-
-const INTENT_STORAGE_KEY = "trails_pending_intents"
-const WORKER_INTERVAL = 30 * SECOND_MS // Check every 30 seconds (reduced from 10s to avoid excessive API calls)
-const INTENT_EXPIRY_TIME = HOUR_MS // 1 hour in milliseconds
-
-interface StoredIntent {
-  intentId: string
-  timestamp: number
-  lastCheckTime?: number
-}
-
-interface IntentExecutionWorkerOptions {
-  trailsClient: TrailsClient
-  trailsApiKey: string
-  sequenceIndexerUrl: string
-  enabled?: boolean
-}
-
-// @preserve - Prevent tree-shaking of this class
-export class IntentExecutionWorker {
-  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: Used in getInstance() and storeIntentForMonitoring()
-  private static instance: IntentExecutionWorker | null = null
-  private intervalId: NodeJS.Timeout | null = null
-  private isRunning = false
-  private trailsClient: TrailsClient
-  private trailsApiKey: string
-  private sequenceIndexerUrl: string
-  private enabled: boolean
-  private abortController: AbortController | null = null
-
-  private constructor(options: IntentExecutionWorkerOptions) {
-    this.trailsClient = options.trailsClient
-    this.trailsApiKey = options.trailsApiKey
-    this.sequenceIndexerUrl = options.sequenceIndexerUrl
-    this.enabled = options.enabled !== false
-  }
-
-  /**
-   * Get or create the singleton instance of IntentExecutionWorker
-   */
-  static getInstance(
-    options?: IntentExecutionWorkerOptions,
-  ): IntentExecutionWorker {
-    if (!IntentExecutionWorker.instance) {
-      if (!options) {
-        throw new Error(
-          "[trails-sdk][intent-worker] Options required for first initialization",
-        )
-      }
-      logger.console.log(
-        "[trails-sdk][intent-worker] Creating singleton instance",
-      )
-      IntentExecutionWorker.instance = new IntentExecutionWorker(options)
-    } else if (options) {
-      // Update the existing instance with new options if provided
-      logger.console.log(
-        "[trails-sdk][intent-worker] Updating existing singleton instance",
-      )
-      IntentExecutionWorker.instance.updateOptions(options)
-    }
-    return IntentExecutionWorker.instance
-  }
-
-  /**
-   * Update the worker options (used when re-initializing with new config)
-   */
-  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: Used in getInstance() method when updating existing instance
-  private updateOptions(options: IntentExecutionWorkerOptions): void {
-    const wasRunning = this.isRunning
-
-    // Stop if running
-    if (wasRunning) {
-      this.stop()
-    }
-
-    // Update options
-    this.trailsClient = options.trailsClient
-    this.trailsApiKey = options.trailsApiKey
-    this.sequenceIndexerUrl = options.sequenceIndexerUrl
-    this.enabled = options.enabled !== false
-
-    // Restart if was running
-    if (wasRunning && this.enabled) {
-      this.start()
-    }
-  }
-
-  /**
-   * Destroy the singleton instance (useful for cleanup/testing)
-   */
-  static destroyInstance(): void {
-    if (IntentExecutionWorker.instance) {
-      logger.console.log(
-        "[trails-sdk][intent-worker] Destroying singleton instance",
-      )
-      IntentExecutionWorker.instance.stop()
-      IntentExecutionWorker.instance = null
-    }
-  }
-
-  /**
-   * Start the worker to monitor pending intents
-   */
-  start(): void {
-    if (!this.enabled) {
-      logger.console.log("[trails-sdk][intent-worker] Worker is disabled")
-      return
-    }
-
-    if (this.isRunning) {
-      logger.console.log(
-        "[trails-sdk][intent-worker] Worker is already running",
-      )
-      return
-    }
-
-    logger.console.log(
-      "[trails-sdk][intent-worker] Starting intent execution worker",
-    )
-    this.isRunning = true
-    this.abortController = new AbortController()
-
-    // Run immediately on start
-    this.checkPendingIntents()
-
-    // Then run periodically
-    this.intervalId = setInterval(() => {
-      this.checkPendingIntents()
-    }, WORKER_INTERVAL)
-  }
-
-  /**
-   * Stop the worker
-   */
-  stop(): void {
-    logger.console.log(
-      "[trails-sdk][intent-worker] Stopping intent execution worker",
-    )
-    this.isRunning = false
-
-    if (this.abortController) {
-      this.abortController.abort()
-      this.abortController = null
-    }
-
-    if (this.intervalId) {
-      clearInterval(this.intervalId)
-      this.intervalId = null
-    }
-  }
-
-  /**
-   * Check all pending intents and process them if needed
-   */
-  private async checkPendingIntents(): Promise<void> {
-    if (!this.isRunning) return
-
-    try {
-      const storedIntents = this.getStoredIntents()
-
-      if (storedIntents.length === 0) {
-        return
-      }
-
-      logger.console.log(
-        `[trails-sdk][intent-worker] Checking ${storedIntents.length} pending intents`,
-      )
-
-      for (const storedIntent of storedIntents) {
-        if (!this.isRunning || this.abortController?.signal.aborted) break
-
-        try {
-          await this.processIntent(storedIntent)
-        } catch (error) {
-          logger.console.error(
-            `[trails-sdk][intent-worker] Error processing intent ${storedIntent.intentId}:`,
-            error,
-          )
-        }
-      }
-    } catch (error) {
-      logger.console.error(
-        "[trails-sdk][intent-worker] Error in checkPendingIntents:",
-        error,
-      )
-    }
-  }
-
-  /**
-   * Process a single intent
-   */
-  private async processIntent(storedIntent: StoredIntent): Promise<void> {
-    const now = Date.now()
-
-    // Check if intent has expired
-    if (now - storedIntent.timestamp > INTENT_EXPIRY_TIME) {
-      logger.console.log(
-        `[trails-sdk][intent-worker] Removing expired intent ${storedIntent.intentId}`,
-      )
-      this.removeStoredIntent(storedIntent.intentId)
-      return
-    }
-
-    // Rate limit checking to avoid too many API calls
-    if (
-      storedIntent.lastCheckTime &&
-      now - storedIntent.lastCheckTime < 5 * SECOND_MS
-    ) {
-      return // Skip if checked within last 5 seconds
-    }
-
-    logger.console.log(
-      `[trails-sdk][intent-worker] Checking intent ${storedIntent.intentId}`,
-    )
-
-    try {
-      // Get current intent status from API
-      const intentResponse = await getIntent(
-        this.trailsClient,
-        storedIntent.intentId,
-      )
-
-      if (!intentResponse || !intentResponse.intent) {
-        logger.console.warn(
-          `[trails-sdk][intent-worker] No intent found for ${storedIntent.intentId}`,
-        )
-        this.updateStoredIntent(storedIntent.intentId, { lastCheckTime: now })
-        return
-      }
-
-      const intent = intentResponse.intent
-      const status = intent.status
-
-      logger.console.log(
-        `[trails-sdk][intent-worker] Intent ${storedIntent.intentId} status: ${status}`,
-      )
-
-      // Update last check time
-      this.updateStoredIntent(storedIntent.intentId, {
-        lastCheckTime: now,
-      })
-
-      // If not in committed state, check if we should remove it
-      if (status !== IntentStatus.COMMITTED) {
-        if (
-          status === IntentStatus.SUCCEEDED ||
-          status === IntentStatus.FAILED ||
-          status === IntentStatus.REFUNDED ||
-          status === IntentStatus.ABORTED ||
-          status === IntentStatus.INVALID ||
-          status === IntentStatus.EXECUTING
-        ) {
-          logger.console.log(
-            `[trails-sdk][intent-worker] Removing intent ${storedIntent.intentId} with final status: ${status}`,
-          )
-          this.removeStoredIntent(storedIntent.intentId)
-        }
-        return
-      }
-
-      // Intent is in committed state - check for deposit transaction
-      logger.console.log(
-        `[trails-sdk][intent-worker] Checking for deposit transaction for intent ${storedIntent.intentId}`,
-      )
-
-      // Get the intent details we need for tracking
-      const originChainId = Number(intent.quoteRequest.originChainId)
-      const originIntentAddress = intent.originIntentAddress
-      const originTokenAddress = intent.quoteRequest.originTokenAddress
-      const depositAmount =
-        intent.quoteRequest.originTokenAmount?.toString() || "0"
-
-      const publicClient = getChainRpcClient(originChainId)
-
-      // Track deposit using resilient tracker
-      const depositReceipt = await trackDepositResilient({
-        publicClient,
-        originChainId,
-        originIntentAddress,
-        originTokenAddress,
-        depositAmount,
-        abortSignal: this.abortController?.signal,
-        sequenceProjectAccessKey: this.trailsApiKey,
-        sequenceIndexerUrl: this.sequenceIndexerUrl,
-        maxRetries: 1, // Just check once, don't wait
-      })
-
-      if (depositReceipt) {
-        logger.console.log(
-          `[trails-sdk][intent-worker] Found deposit transaction for intent ${storedIntent.intentId}:`,
-          depositReceipt.transactionHash,
-        )
-
-        // Execute the intent with the deposit transaction hash
-        try {
-          const executeResponse = await executeIntent(
-            this.trailsClient,
-            storedIntent.intentId,
-            depositReceipt.transactionHash,
-          )
-
-          logger.console.log(
-            `[trails-sdk][intent-worker] Successfully executed intent ${storedIntent.intentId}:`,
-            executeResponse,
-          )
-
-          // Remove from storage after successful execution
-          this.removeStoredIntent(storedIntent.intentId)
-        } catch (executeError) {
-          logger.console.error(
-            `[trails-sdk][intent-worker] Failed to execute intent ${storedIntent.intentId}:`,
-            executeError,
-          )
-          // Keep in storage to retry later
-          this.updateStoredIntent(storedIntent.intentId, { lastCheckTime: now })
-        }
-      } else {
-        // No deposit found yet, update check time
-        this.updateStoredIntent(storedIntent.intentId, { lastCheckTime: now })
-      }
-    } catch (error) {
-      logger.console.error(
-        `[trails-sdk][intent-worker] Error processing intent ${storedIntent.intentId}:`,
-        error,
-      )
-      this.updateStoredIntent(storedIntent.intentId, { lastCheckTime: now })
-    }
-  }
-
-  /**
-   * Store an intent ID for monitoring
-   * @preserve
-   */
-  static storeIntentForMonitoring(intentId: string): void {
-    try {
-      logger.console.log(
-        `[trails-sdk][intent-worker] storeIntentForMonitoring called with intentId: ${intentId}`,
-      )
-
-      const storedIntent: StoredIntent = {
-        intentId,
-        timestamp: Date.now(),
-      }
-
-      const existingIntents = IntentExecutionWorker.getStoredIntentsStatic()
-
-      logger.console.log(
-        `[trails-sdk][intent-worker] Current stored intents:`,
-        existingIntents,
-      )
-
-      // Check if intent already exists
-      const existingIndex = existingIntents.findIndex(
-        (i) => i.intentId === intentId,
-      )
-      if (existingIndex >= 0) {
-        // Update existing intent
-        logger.console.log(
-          `[trails-sdk][intent-worker] Updating existing intent at index ${existingIndex}`,
-        )
-        existingIntents[existingIndex] = storedIntent
-      } else {
-        // Add new intent
-        logger.console.log(
-          `[trails-sdk][intent-worker] Adding new intent to storage`,
-        )
-        existingIntents.push(storedIntent)
-      }
-
-      localStorage.setItem(INTENT_STORAGE_KEY, JSON.stringify(existingIntents))
-
-      // Verify it was actually stored
-      const verifyStored = localStorage.getItem(INTENT_STORAGE_KEY)
-      logger.console.log(
-        `[trails-sdk][intent-worker] Verification - localStorage content after storing:`,
-        verifyStored,
-      )
-
-      logger.console.log(
-        `[trails-sdk][intent-worker] Successfully stored intent ${intentId} for monitoring. Total intents: ${existingIntents.length}`,
-      )
-
-      // Check if the singleton worker exists and is running
-      // This ensures the worker is available to process stored intents
-      if (!IntentExecutionWorker.instance) {
-        logger.console.warn(
-          "[trails-sdk][intent-worker] Worker singleton not initialized. Intent stored but won't be processed until TrailsProvider initializes the worker.",
-        )
-      } else if (!IntentExecutionWorker.instance.isRunning) {
-        logger.console.log(
-          "[trails-sdk][intent-worker] Starting worker to process stored intent",
-        )
-        IntentExecutionWorker.instance.start()
-      }
-    } catch (error) {
-      logger.console.error(
-        "[trails-sdk][intent-worker] Failed to store intent for monitoring:",
-        error,
-      )
-    }
-  }
-
-  /**
-   * Get stored intents (static version for external use)
-   */
-  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: Used in storeIntentForMonitoring() and getStoredIntents() methods
-  private static getStoredIntentsStatic(): StoredIntent[] {
-    try {
-      const stored = localStorage.getItem(INTENT_STORAGE_KEY)
-      if (!stored) return []
-
-      const intents = JSON.parse(stored) as StoredIntent[]
-      return Array.isArray(intents) ? intents : []
-    } catch (error) {
-      logger.console.error(
-        "[trails-sdk][intent-worker] Failed to retrieve stored intents:",
-        error,
-      )
-      return []
-    }
-  }
-
-  /**
-   * Get stored intents
-   */
-  private getStoredIntents(): StoredIntent[] {
-    return IntentExecutionWorker.getStoredIntentsStatic()
-  }
-
-  /**
-   * Update a stored intent
-   */
-  private updateStoredIntent(
-    intentId: string,
-    updates: Partial<Omit<StoredIntent, "intentId">>,
-  ): void {
-    try {
-      const intents = this.getStoredIntents()
-      const index = intents.findIndex((i) => i.intentId === intentId)
-
-      if (index >= 0 && intents[index]) {
-        const existingIntent = intents[index]
-        intents[index] = {
-          ...existingIntent,
-          ...updates,
-          intentId: existingIntent.intentId,
-          timestamp: existingIntent.timestamp,
-        }
-        localStorage.setItem(INTENT_STORAGE_KEY, JSON.stringify(intents))
-      }
-    } catch (error) {
-      logger.console.error(
-        `[trails-sdk][intent-worker] Failed to update intent ${intentId}:`,
-        error,
-      )
-    }
-  }
-
-  /**
-   * Remove a stored intent
-   */
-  private removeStoredIntent(intentId: string): void {
-    try {
-      const intents = this.getStoredIntents()
-      const filtered = intents.filter((i) => i.intentId !== intentId)
-      localStorage.setItem(INTENT_STORAGE_KEY, JSON.stringify(filtered))
-
-      logger.console.log(
-        `[trails-sdk][intent-worker] Removed intent ${intentId} from monitoring`,
-      )
-    } catch (error) {
-      logger.console.error(
-        `[trails-sdk][intent-worker] Failed to remove intent ${intentId}:`,
-        error,
-      )
-    }
-  }
-
-  /**
-   * Clear all stored intents (useful for cleanup/testing)
-   */
-  static clearAllStoredIntents(): void {
-    try {
-      localStorage.removeItem(INTENT_STORAGE_KEY)
-      logger.console.log(
-        "[trails-sdk][intent-worker] Cleared all stored intents",
-      )
-    } catch (error) {
-      logger.console.error(
-        "[trails-sdk][intent-worker] Failed to clear stored intents:",
-        error,
-      )
-    }
-  }
-}