0xtrails 0.13.2 → 0.14.0

package/src/decoders.ts

@@ -1,365 +0,0 @@
-import type { TransactionReceipt, Log } from "viem"
-import { decodeEventLog, parseAbiItem } from "viem"
-
-// Corrected ABI items
-const CALL_SUCCEEDED_ABI = parseAbiItem(
-  "event CallSucceeded(bytes32 _opHash, uint256 _index)",
-)
-
-const CALL_FAILED_ABI = parseAbiItem(
-  "event CallFailed(bytes32 _opHash, uint256 _index, bytes _returnData)",
-)
-
-const CALL_ABORTED_ABI = parseAbiItem(
-  "event CallAborted(bytes32 _opHash, uint256 _index, bytes _returnData)",
-)
-
-// only `deploymentId` is indexed
-const CALL_SKIPPED_ABI = parseAbiItem(
-  "event CallSkipped(bytes32 indexed deploymentId, uint256 actionIndex)",
-)
-
-// Refund / Sweep events come from the Trails Token Sweeper contract.
-// Contract source and event definitions:
-// - https://github.com/0xsequence/trails-contracts/pull/28
-// - https://github.com/0xsequence/stack/pull/1249
-const REFUND_ABI = parseAbiItem(
-  "event Refund(address indexed token, address indexed recipient, uint256 amount)",
-)
-
-const SWEEP_ABI = parseAbiItem(
-  "event Sweep(address indexed token, address indexed recipient, uint256 amount)",
-)
-
-const REFUND_AND_SWEEP_ABI = parseAbiItem(
-  "event RefundAndSweep(address indexed token, address indexed refundRecipient, uint256 refundAmount, address indexed sweepRecipient, uint256 actualRefund, uint256 remaining)",
-)
-
-// Event types
-export interface CallSucceededEvent {
-  type: "CallSucceeded"
-  opHash: string
-  index: bigint
-  log: Log
-}
-
-export interface CallFailedEvent {
-  type: "CallFailed"
-  opHash: string
-  index: bigint
-  returnData: string
-  log: Log
-}
-
-export interface CallAbortedEvent {
-  type: "CallAborted"
-  opHash: string
-  index: bigint
-  returnData: string
-  log: Log
-}
-
-export interface CallSkippedEvent {
-  type: "CallSkipped"
-  deploymentId: string
-  actionIndex: bigint
-  log: Log
-}
-
-export interface RefundEvent {
-  type: "Refund"
-  token: string
-  recipient: string
-  amount: bigint
-  log: Log
-}
-
-export interface SweepEvent {
-  type: "Sweep"
-  token: string
-  recipient: string
-  amount: bigint
-  log: Log
-}
-
-export interface RefundAndSweepEvent {
-  type: "RefundAndSweep"
-  token: string
-  refundRecipient: string
-  refundAmount: bigint
-  sweepRecipient: string
-  actualRefund: bigint
-  remaining: bigint
-  log: Log
-}
-
-export type GuestModuleEvent =
-  | CallSucceededEvent
-  | CallFailedEvent
-  | CallAbortedEvent
-  | CallSkippedEvent
-
-// Trails Token Sweeper events: see PR references above for canonical specs.
-export type TokenSweeperEvent = RefundEvent | SweepEvent | RefundAndSweepEvent
-
-// === Decoders ===
-
-export function decodeCallSucceeded(log: Log): CallSucceededEvent | null {
-  try {
-    const decoded = decodeEventLog({
-      abi: [CALL_SUCCEEDED_ABI],
-      data: log.data,
-      topics: log.topics,
-      strict: false,
-    }) as {
-      eventName: "CallSucceeded"
-      args: { _opHash: string; _index: bigint }
-    }
-
-    return {
-      type: "CallSucceeded",
-      opHash: decoded.args._opHash,
-      index: decoded.args._index,
-      log,
-    }
-  } catch {
-    return null
-  }
-}
-
-export function decodeCallFailed(log: Log): CallFailedEvent | null {
-  try {
-    const decoded = decodeEventLog({
-      abi: [CALL_FAILED_ABI],
-      data: log.data,
-      topics: log.topics,
-      strict: false,
-    }) as {
-      eventName: "CallFailed"
-      args: { _opHash: string; _index: bigint; _returnData: string }
-    }
-
-    return {
-      type: "CallFailed",
-      opHash: decoded.args._opHash,
-      index: decoded.args._index,
-      returnData: decoded.args._returnData,
-      log,
-    }
-  } catch {
-    return null
-  }
-}
-
-export function decodeCallAborted(log: Log): CallAbortedEvent | null {
-  try {
-    const decoded = decodeEventLog({
-      abi: [CALL_ABORTED_ABI],
-      data: log.data,
-      topics: log.topics,
-      strict: false,
-    }) as {
-      eventName: "CallAborted"
-      args: { _opHash: string; _index: bigint; _returnData: string }
-    }
-
-    return {
-      type: "CallAborted",
-      opHash: decoded.args._opHash,
-      index: decoded.args._index,
-      returnData: decoded.args._returnData,
-      log,
-    }
-  } catch {
-    return null
-  }
-}
-
-export function decodeCallSkipped(log: Log): CallSkippedEvent | null {
-  try {
-    const decoded = decodeEventLog({
-      abi: [CALL_SKIPPED_ABI],
-      data: log.data,
-      topics: log.topics,
-      strict: false,
-    }) as {
-      eventName: "CallSkipped"
-      args: { deploymentId: string; actionIndex: bigint }
-    }
-
-    return {
-      type: "CallSkipped",
-      deploymentId: decoded.args.deploymentId,
-      actionIndex: decoded.args.actionIndex,
-      log,
-    }
-  } catch {
-    return null
-  }
-}
-
-export function decodeRefund(log: Log): RefundEvent | null {
-  try {
-    const decoded = decodeEventLog({
-      abi: [REFUND_ABI],
-      data: log.data,
-      topics: log.topics,
-      strict: false,
-    }) as {
-      eventName: "Refund"
-      args: { token: string; recipient: string; amount: bigint }
-    }
-
-    return {
-      type: "Refund",
-      token: decoded.args.token,
-      recipient: decoded.args.recipient,
-      amount: decoded.args.amount,
-      log,
-    }
-  } catch {
-    return null
-  }
-}
-
-export function decodeRefundAndSweep(log: Log): RefundAndSweepEvent | null {
-  try {
-    const decoded = decodeEventLog({
-      abi: [REFUND_AND_SWEEP_ABI],
-      data: log.data,
-      topics: log.topics,
-      strict: false,
-    }) as {
-      eventName: "RefundAndSweep"
-      args: {
-        token: string
-        refundRecipient: string
-        refundAmount: bigint
-        sweepRecipient: string
-        actualRefund: bigint
-        remaining: bigint
-      }
-    }
-
-    return {
-      type: "RefundAndSweep",
-      token: decoded.args.token,
-      refundRecipient: decoded.args.refundRecipient,
-      refundAmount: decoded.args.refundAmount,
-      sweepRecipient: decoded.args.sweepRecipient,
-      actualRefund: decoded.args.actualRefund,
-      remaining: decoded.args.remaining,
-      log,
-    }
-  } catch {
-    return null
-  }
-}
-
-export function decodeSweep(log: Log): SweepEvent | null {
-  try {
-    const decoded = decodeEventLog({
-      abi: [SWEEP_ABI],
-      data: log.data,
-      topics: log.topics,
-      strict: false,
-    }) as {
-      eventName: "Sweep"
-      args: { token: string; recipient: string; amount: bigint }
-    }
-
-    return {
-      type: "Sweep",
-      token: decoded.args.token,
-      recipient: decoded.args.recipient,
-      amount: decoded.args.amount,
-      log,
-    }
-  } catch {
-    return null
-  }
-}
-
-// === Main decoder ===
-
-export function decodeTokenSweeperEvents(
-  receipt: TransactionReceipt,
-): TokenSweeperEvent[] {
-  const events: TokenSweeperEvent[] = []
-
-  for (const log of receipt.logs) {
-    const refund = decodeRefund(log)
-    if (refund) {
-      events.push(refund)
-      continue
-    }
-
-    const refundAndSweep = decodeRefundAndSweep(log)
-    if (refundAndSweep) {
-      events.push(refundAndSweep)
-      continue
-    }
-
-    const sweep = decodeSweep(log)
-    if (sweep) {
-      events.push(sweep)
-    }
-  }
-
-  return events
-}
-
-export function decodeGuestModuleEvents(
-  receipt: TransactionReceipt,
-): GuestModuleEvent[] {
-  const events: GuestModuleEvent[] = []
-
-  for (const log of receipt.logs) {
-    const succeeded = decodeCallSucceeded(log)
-    if (succeeded) {
-      events.push(succeeded)
-      continue
-    }
-
-    const failed = decodeCallFailed(log)
-    if (failed) {
-      events.push(failed)
-      continue
-    }
-
-    const aborted = decodeCallAborted(log)
-    if (aborted) {
-      events.push(aborted)
-      continue
-    }
-
-    const skipped = decodeCallSkipped(log)
-    if (skipped) {
-      events.push(skipped)
-    }
-  }
-
-  return events
-}
-
-// === Utilities ===
-
-export function getEventsByType<T extends GuestModuleEvent["type"]>(
-  events: GuestModuleEvent[],
-  type: T,
-): Extract<GuestModuleEvent, { type: T }>[] {
-  return events.filter(
-    (event): event is Extract<GuestModuleEvent, { type: T }> =>
-      event.type === type,
-  )
-}
-
-export function getFirstEventByType<T extends GuestModuleEvent["type"]>(
-  events: GuestModuleEvent[],
-  type: T,
-): Extract<GuestModuleEvent, { type: T }> | undefined {
-  return events.find(
-    (event): event is Extract<GuestModuleEvent, { type: T }> =>
-      event.type === type,
-  )
-}

package/src/ens.ts

@@ -1,74 +0,0 @@
-import { mainnet } from "viem/chains"
-import { useEnsAddress, useEnsAvatar, useEnsName } from "wagmi"
-import { normalize } from "viem/ens"
-import { queryPersister } from "./query/persister.js"
-import { DAY_MS } from "./utils/time.js"
-
-/** 24 hours in ms – ENS data is cached and persisted to localStorage for this duration. */
-const ENS_CACHE_MS = DAY_MS
-
-export function useResolveEnsAddress({ textInput }: { textInput: string }) {
-  const { data: ensAddress, isLoading } = useEnsAddress({
-    name: textInput?.endsWith(".eth") ? textInput : undefined,
-    chainId: mainnet.id,
-    query: {
-      enabled: !!textInput && textInput.endsWith(".eth"),
-      staleTime: ENS_CACHE_MS,
-      gcTime: ENS_CACHE_MS,
-      persister: queryPersister.persisterFn,
-    },
-  })
-
-  return {
-    ensAddress,
-    isLoading,
-  }
-}
-
-export function useResolveEnsName({ address }: { address: string }) {
-  const { data: ensName, isLoading } = useEnsName({
-    address: address?.startsWith("0x") ? (address as `0x${string}`) : undefined,
-    chainId: mainnet.id,
-    query: {
-      enabled: !!address && address.startsWith("0x"),
-      staleTime: ENS_CACHE_MS,
-      gcTime: ENS_CACHE_MS,
-      persister: queryPersister.persisterFn,
-    },
-  })
-
-  return {
-    ensName,
-    isLoading,
-  }
-}
-
-export function useResolveEns({ address }: { address: string }) {
-  const { data: ensName, isLoading: isLoadingEnsName } = useEnsName({
-    address: address?.startsWith("0x") ? (address as `0x${string}`) : undefined,
-    chainId: mainnet.id,
-    query: {
-      enabled: !!address && address.startsWith("0x"),
-      staleTime: ENS_CACHE_MS,
-      gcTime: ENS_CACHE_MS,
-      persister: queryPersister.persisterFn,
-    },
-  })
-
-  const { data: ensAvatar, isLoading: isLoadingEnsAvatar } = useEnsAvatar({
-    name: ensName ? normalize(ensName) : undefined,
-    chainId: mainnet.id,
-    query: {
-      enabled: !!address && address.startsWith("0x") && !!ensName,
-      staleTime: ENS_CACHE_MS,
-      gcTime: ENS_CACHE_MS,
-      persister: queryPersister.persisterFn,
-    },
-  })
-
-  return {
-    ensName,
-    ensAvatar,
-    isLoading: isLoadingEnsName || isLoadingEnsAvatar,
-  }
-}

package/src/error.ts

@@ -1,268 +0,0 @@
-export function getFullErrorMessage(err: any) {
-  const messages = []
-
-  let current = err
-  while (current) {
-    if (typeof current === "string") {
-      messages.push(current)
-    }
-    if (typeof current.message === "string") {
-      messages.push(current.message)
-    }
-
-    // Check for nested error cause
-    current = current.cause ?? current.originalError ?? current.error ?? null
-  }
-
-  return messages.join(" | Caused by: ")
-}
-
-export function getErrorString(err: unknown): string {
-  return err instanceof Error ? err.message : (err?.toString() ?? "")
-}
-
-export function getIsAlreadyExecutingError(err: unknown): boolean {
-  return getFullErrorMessage(err).includes("EXECUTING")
-}
-
-export function getIntentStatusFromError(err: unknown): string | null {
-  const match = getFullErrorMessage(err).match(
-    /status=(COMMITTED|EXECUTING|SUCCEEDED|FAILED|REFUNDED|ABORTED|INVALID)/,
-  )
-
-  return match?.[1] ?? null
-}
-
-export function getIsUserRejectionError(
-  err: unknown,
-): err is UserRejectionError {
-  // Check if it's an instance of UserRejectionError (or has the name property)
-  if (
-    err instanceof UserRejectionError ||
-    (err instanceof Error && err.name === "UserRejectionError")
-  ) {
-    return true
-  }
-
-  // Check if the error message indicates a user rejection
-  // Use getFullErrorMessage to check nested error messages as well
-  // Match patterns like: "rejected", "denied", "user rejected", "denied transaction signature", etc.
-  const errorString = getFullErrorMessage(err).toLowerCase()
-  const isRejected =
-    /rejected|denied|user rejected|denied transaction signature|user denied transaction|user denied the request/gi.test(
-      errorString,
-    )
-  return isRejected
-}
-
-export function getIsPopupBlockedError(err: unknown) {
-  const isPopupBlocked = /Failed to initialize request/gi.test(
-    getErrorString(err).toLowerCase(),
-  )
-  return isPopupBlocked
-}
-
-export function getIsBalanceTooLowError(err: unknown) {
-  const isBalanceTooLow =
-    /have enough balance|not enough balance|insufficient balance|insufficient funds|not enough funds|too low/gi.test(
-      getErrorString(err).toLowerCase(),
-    )
-  return isBalanceTooLow
-}
-
-export class InsufficientBalanceError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = "InsufficientBalanceError"
-  }
-}
-
-export class UserRejectionError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = "UserRejectionError"
-  }
-}
-
-export function getIsApiError(err: unknown) {
-  const isApiError = /request aborted|not deployed/gi.test(
-    getErrorString(err).toLowerCase(),
-  )
-  return isApiError
-}
-
-export function getIsRateLimitedError(err: unknown) {
-  const isRateLimited = /slow down|request rate|rate limit/gi.test(
-    getErrorString(err).toLowerCase(),
-  )
-  return isRateLimited
-}
-
-export function getIsRequiredAmountNotMetError(err: unknown) {
-  // Example error:
-  // GetIntentsQuote failed: total required amount (196159816026182793237) exceeds user-specified maximum (21960919303474978846)
-  const isRequiredAmountNotMet = /exceeds user-specified maximum/gi.test(
-    getErrorString(err).toLowerCase(),
-  )
-  return isRequiredAmountNotMet
-}
-
-export function getIsNoAvailableQuoteError(err: unknown) {
-  const isNoAvailableQuote =
-    /no available quotes|failed to get quote from any provider/gi.test(
-      getErrorString(err).toLowerCase(),
-    )
-  return isNoAvailableQuote
-}
-
-export function getIsQuoteFailedError(err: unknown) {
-  const isQuoteFailed = /GetIntentsQuote failed/gi.test(
-    getErrorString(err).toLowerCase(),
-  )
-  return isQuoteFailed
-}
-
-export function getIsQuoteTokenError(err: unknown) {
-  const isQuoteTokenError =
-    /requires destination token to be USDC|Token or chain not found/gi.test(
-      getErrorString(err).toLowerCase(),
-    )
-  return isQuoteTokenError
-}
-
-export function getIsQuoteInputError(err: unknown) {
-  const isQuoteInputError =
-    /Invalid input or output currency|originTokenAmount must be greater than zero|trails fee is greater than the origin token amount|insufficient origin amount|fees exceed the provided amount/gi.test(
-      getErrorString(err).toLowerCase(),
-    )
-  return isQuoteInputError
-}
-
-export function getIsHighPriceImpactError(err: unknown) {
-  return /HighPriceImpact|high price impact/gi.test(getFullErrorMessage(err))
-}
-
-export function getIsInsufficientLiquidityError(err: unknown) {
-  const isInsufficientLiquidity =
-    /insufficient liquidity|higher than the available liquidity/gi.test(
-      getErrorString(err).toLowerCase(),
-    )
-  return isInsufficientLiquidity
-}
-
-export function getIsWalletAlreadyConnectedError(err: unknown) {
-  const isWalletAlreadyConnected = /Connector already connected/gi.test(
-    getErrorString(err).toLowerCase(),
-  )
-  return isWalletAlreadyConnected
-}
-
-export function getIsNetworkError(err: unknown) {
-  const errorMessage = getFullErrorMessage(err).toLowerCase()
-  return (
-    errorMessage.includes("failed to fetch") ||
-    errorMessage.includes("fetch failed") ||
-    errorMessage.includes("http request failed") ||
-    errorMessage.includes("request failed") ||
-    errorMessage.includes("timeout") ||
-    errorMessage.includes("etimedout") ||
-    errorMessage.includes("econnrefused") ||
-    errorMessage.includes("enotfound") ||
-    errorMessage.includes("eai_again") ||
-    errorMessage.includes("networkerror") ||
-    errorMessage.includes("err_network") ||
-    errorMessage.includes("aborterror") ||
-    errorMessage.includes("connection error") ||
-    errorMessage.includes("network")
-  )
-}
-
-export function getIsCorsError(err: unknown) {
-  const errorMessage = getFullErrorMessage(err).toLowerCase()
-  return (
-    errorMessage.includes("cross-origin") ||
-    errorMessage.includes("cors") ||
-    errorMessage.includes("same origin policy")
-  )
-}
-
-export function getIsOnrampAmountTooLowError(err: unknown) {
-  const fullErrorMessage = getFullErrorMessage(err).toLowerCase()
-  const isOnrampAmountTooLow =
-    /meld: source amount is below the minimum allowed|invalid_amount_too_low|amount.*too low.*minimum/gi.test(
-      fullErrorMessage,
-    )
-  return isOnrampAmountTooLow
-}
-
-export function getPrettifiedErrorMessage(
-  err: unknown,
-  defaultMessage: string = "",
-) {
-  // Check for "No route available" error (timeout or no routes)
-  const fullErrorMessage = getFullErrorMessage(err)
-  if (fullErrorMessage.toLowerCase().includes("no route available")) {
-    return "No route available"
-  }
-
-  const isRequiredAmountNotMet = getIsRequiredAmountNotMetError(err)
-  if (isRequiredAmountNotMet) {
-    return "The requested amount is too low to retrieve a quote or the account has insufficient funds to meet the required amount. Try again with a higher amount or make sure you have enough funds."
-  }
-  const isInsufficientLiquidity = getIsInsufficientLiquidityError(err)
-  if (isInsufficientLiquidity) {
-    return "The requested amount is too high to retrieve a quote. Try again with a lower amount."
-  }
-  const isNoAvailableQuote = getIsNoAvailableQuoteError(err)
-  if (isNoAvailableQuote) {
-    return "No quote found for the selected pair and/or amount. Try again with a different pair and/or amount."
-  }
-  const isQuoteTokenError = getIsQuoteTokenError(err)
-  if (isQuoteTokenError) {
-    return "The selected token is not supported. Please try again with a different token."
-  }
-  const isQuoteInputError = getIsQuoteInputError(err)
-  if (isQuoteInputError) {
-    return "No quote found for the input amount. Try again with a higher amount."
-  }
-  const isQuoteFailed = getIsQuoteFailedError(err)
-  if (isQuoteFailed) {
-    return "No quote found for the selected pair and amount."
-  }
-  const isApiError = getIsApiError(err)
-  if (isApiError) {
-    return "An API error occurred. Please try again later."
-  }
-  const isUserRejectionError = getIsUserRejectionError(err)
-  if (isUserRejectionError) {
-    return "The wallet rejected the request. Please try again."
-  }
-  const isWalletAlreadyConnected = getIsWalletAlreadyConnectedError(err)
-  if (isWalletAlreadyConnected) {
-    return "The wallet is already connected"
-  }
-  if (fullErrorMessage.toLowerCase().includes("invalid intent signature")) {
-    return "The transaction signature was invalid. Please try again."
-  }
-  if (fullErrorMessage.toLowerCase().includes("transaction aborted")) {
-    return "The transaction was aborted. Please try again."
-  }
-  if (getIsHighPriceImpactError(err)) {
-    return "This quote is unavailable due to high price impact (>30%) on a large transfer. Try a smaller amount."
-  }
-  const isOnrampAmountTooLow = getIsOnrampAmountTooLowError(err)
-  if (isOnrampAmountTooLow) {
-    // Try to extract minimum amount from error message
-    const minAmountMatch = fullErrorMessage.match(
-      /minimum allowed.*?is ([\d.]+\s*[A-Z]{3})/i,
-    )
-    const minAmount = minAmountMatch ? minAmountMatch[1] : null
-
-    if (minAmount) {
-      return `The requested amount is too low. The minimum amount is ${minAmount}. Please try again with a higher amount.`
-    }
-    return "The requested amount is too low to retrieve a quote. Try again with a higher amount."
-  }
-
-  return defaultMessage
-}