0xtrails 0.13.2 → 0.15.0

package/src/transactionIntent/helpers/index.ts

@@ -1 +0,0 @@
-export * from "./transactionStateHelpers.js"

package/src/transactionIntent/helpers/transactionStateHelpers.ts

@@ -1,440 +0,0 @@
-import type { TransactionReceipt } from "viem"
-import type { IntentReceipt, TransactionStateInfo } from "@0xtrails/api"
-import type {
-  TransactionState,
-  TransactionStateStatus,
-} from "../../transactions.js"
-import { getExplorerUrl } from "../../explorer.js"
-import {
-  decodeTokenSweeperEvents,
-  decodeGuestModuleEvents,
-} from "../../decoders.js"
-import { logger } from "../../logger.js"
-import { isDisplayableTransactionHash } from "../../transactions.js"
-
-// Re-export for convenience
-export type { TransactionStateInfo } from "@0xtrails/api"
-
-/**
- * Convert API transactionStates to SDK TransactionState type.
- * This normalizes the backend response format to the internal SDK format.
- */
-export function getNormalizedTransactionStates(params: {
-  transactionStates: TransactionStateInfo[]
-}): TransactionState[] {
-  const { transactionStates } = params
-
-  return transactionStates.map((apiState) => {
-    return {
-      id: apiState.id,
-      transactionHash: "",
-      explorerUrl: "",
-      blockNumber: undefined,
-      chainId: apiState.chainId,
-      state: "pending" as TransactionStateStatus,
-      label: apiState.label,
-      txnMinedAt: undefined,
-    }
-  })
-}
-
-/**
- * Immutably update a transaction state by its label.
- * Returns a new array with the updated state.
- */
-export function updateTransactionState(
-  currentStates: TransactionState[],
-  stateLabel: string,
-  update: {
-    transactionHash?: string
-    blockNumber?: number
-    state?: TransactionStateStatus
-    txnMinedAt?: string
-    explorerUrl?: string
-    refunded?: boolean
-    refundTransactionHash?: string
-    refundTransactionChainId?: number
-  },
-): TransactionState[] {
-  return currentStates.map((txState) => {
-    if (txState.label !== stateLabel) {
-      return txState
-    }
-
-    const updatedState: TransactionState = { ...txState }
-
-    if (update.transactionHash !== undefined) {
-      updatedState.transactionHash = update.transactionHash
-      // Auto-generate explorer URL if hash is provided
-      updatedState.explorerUrl = getExplorerUrl({
-        txHash: update.transactionHash,
-        chainId: txState.chainId,
-      })
-    }
-
-    if (update.explorerUrl !== undefined) {
-      updatedState.explorerUrl = update.explorerUrl
-    }
-
-    if (update.blockNumber !== undefined) {
-      updatedState.blockNumber = update.blockNumber
-    }
-
-    if (update.state !== undefined) {
-      updatedState.state = update.state
-    }
-
-    if (update.txnMinedAt !== undefined) {
-      updatedState.txnMinedAt = update.txnMinedAt
-    }
-
-    if (update.refunded !== undefined) {
-      updatedState.refunded = update.refunded
-    }
-
-    if (update.refundTransactionHash !== undefined) {
-      updatedState.refundTransactionHash = update.refundTransactionHash
-    }
-
-    if (update.refundTransactionChainId !== undefined) {
-      updatedState.refundTransactionChainId = update.refundTransactionChainId
-    }
-
-    return updatedState
-  })
-}
-
-/**
- * Update a transaction state with decoded events from a transaction receipt.
- * Decodes both TokenSweeper and GuestModule events and updates the state accordingly.
- * Returns a new array with the updated state.
- */
-export function updateTransactionStateWithDecodedEvents(
-  currentStates: TransactionState[],
-  stateLabel: string,
-  receipt: TransactionReceipt,
-  chainId: number,
-): TransactionState[] {
-  return currentStates.map((txState) => {
-    if (txState.label !== stateLabel) {
-      return txState
-    }
-
-    const updatedState: TransactionState = { ...txState }
-
-    // Update basic receipt info
-    updatedState.transactionHash = receipt.transactionHash
-    updatedState.explorerUrl = getExplorerUrl({
-      txHash: receipt.transactionHash,
-      chainId,
-    })
-    updatedState.blockNumber = Number(receipt.blockNumber)
-    updatedState.state = receipt.status === "success" ? "confirmed" : "failed"
-
-    try {
-      // Decode TokenSweeper events
-      const tokenSweeperEvents = decodeTokenSweeperEvents(receipt)
-      updatedState.decodedTokenSweeperEvents = tokenSweeperEvents
-
-      // Decode GuestModule events
-      const guestModuleEvents = decodeGuestModuleEvents(receipt)
-      updatedState.decodedGuestModuleEvents = guestModuleEvents
-
-      // Check for refund
-      const hasRefund =
-        tokenSweeperEvents.findIndex(
-          (event) => event.type === "Refund" || event.type === "RefundAndSweep",
-        ) !== -1
-
-      // Check for call failure with sweep (indicates refund scenario)
-      const hasSweepWithCallFailed =
-        tokenSweeperEvents.findIndex((event) => event.type === "Sweep") !==
-          -1 &&
-        guestModuleEvents.findIndex((event) => event.type === "CallFailed") !==
-          -1
-
-      updatedState.refunded = hasRefund || hasSweepWithCallFailed
-
-      logger.console.log("[trails-sdk] Transaction state decoded events", {
-        id: updatedState.id,
-        label: stateLabel,
-        chainId,
-        callFailed: guestModuleEvents.filter((e) => e.type === "CallFailed")
-          .length,
-        sweeperEvents: tokenSweeperEvents.length,
-        refunded: updatedState.refunded,
-      })
-    } catch (error) {
-      logger.console.error(
-        "[trails-sdk] Error decoding transaction events",
-        error,
-      )
-    }
-
-    return updatedState
-  })
-}
-
-/**
- * Update a transaction state at a specific index.
- * Returns a new array with the updated state.
- */
-export function updateTransactionStateAtIndex(
-  currentStates: TransactionState[],
-  index: number,
-  update: Partial<TransactionState>,
-): TransactionState[] {
-  if (index < 0 || index >= currentStates.length) {
-    return currentStates
-  }
-
-  return currentStates.map((txState, i) => {
-    if (i !== index) {
-      return txState
-    }
-    return { ...txState, ...update }
-  })
-}
-
-export function mapIntentTransactionStatus(
-  status?: string | null,
-): TransactionStateStatus | null {
-  if (!status) return null
-  if (status === "SUCCEEDED") return "confirmed"
-  if (status === "ABORTED") return "aborted"
-  if (status === "FAILED" || status === "ERRORED" || status === "REVERTED") {
-    return "failed"
-  }
-  return "pending"
-}
-
-export function applyIntentReceiptToTransactionStates(params: {
-  currentStates: TransactionState[]
-  receipt: IntentReceipt
-}): { transactionStates: TransactionState[]; changed: boolean } {
-  const { currentStates, receipt } = params
-
-  if (currentStates.length === 0) {
-    return { transactionStates: currentStates, changed: false }
-  }
-
-  const nextStates = [...currentStates]
-  let changed = false
-
-  const applyAtIndex = (
-    index: number,
-    status?: string | null,
-    txnHash?: string | null,
-    txnMinedAt?: string | null,
-  ) => {
-    const targetState = nextStates[index]
-    const mappedState = mapIntentTransactionStatus(status)
-    if (!targetState || !mappedState) {
-      return
-    }
-
-    const hasNewDisplayableHash = isDisplayableTransactionHash(txnHash)
-    const displayableHash = hasNewDisplayableHash
-      ? txnHash
-      : targetState.transactionHash || ""
-    const nextExplorerUrl = displayableHash
-      ? getExplorerUrl({
-          txHash: displayableHash,
-          chainId: targetState.chainId,
-        })
-      : targetState.explorerUrl || ""
-
-    const stateChanged =
-      targetState.state !== mappedState ||
-      targetState.transactionHash !== displayableHash ||
-      targetState.explorerUrl !== nextExplorerUrl ||
-      targetState.txnMinedAt !== (txnMinedAt || undefined)
-
-    if (!stateChanged) {
-      return
-    }
-
-    nextStates[index] = {
-      ...targetState,
-      state: mappedState,
-      transactionHash: displayableHash,
-      explorerUrl: nextExplorerUrl,
-      txnMinedAt: txnMinedAt || undefined,
-    }
-    changed = true
-  }
-
-  applyAtIndex(
-    0,
-    receipt.depositTransaction?.status,
-    receipt.depositTransaction?.txnHash,
-    receipt.depositTransaction?.txnMinedAt,
-  )
-
-  const originStateIndex = nextStates.length > 1 ? 1 : 0
-  applyAtIndex(
-    originStateIndex,
-    receipt.originTransaction?.status,
-    receipt.originTransaction?.txnHash,
-    receipt.originTransaction?.txnMinedAt,
-  )
-
-  const destinationStateIndex = nextStates.length - 1
-  applyAtIndex(
-    destinationStateIndex,
-    receipt.destinationTransaction?.status,
-    receipt.destinationTransaction?.txnHash,
-    receipt.destinationTransaction?.txnMinedAt,
-  )
-
-  return {
-    transactionStates: changed ? nextStates : currentStates,
-    changed,
-  }
-}
-
-export function hasIntentReceiptObservedFundingProgress(
-  receipt: IntentReceipt,
-): boolean {
-  return (
-    receipt.depositTransaction?.status === "SUCCEEDED" ||
-    receipt.originTransaction?.status === "MINING" ||
-    receipt.originTransaction?.status === "SUCCEEDED" ||
-    receipt.destinationTransaction?.status === "MINING" ||
-    receipt.destinationTransaction?.status === "SUCCEEDED"
-  )
-}
-
-/**
- * Apply refund information from an intent receipt to the transaction states.
- * Finds the appropriate transaction by chainId and updates refund fields.
- */
-export function applyRefundFromIntentReceipt(
-  currentStates: TransactionState[],
-  receipt: {
-    status?: string
-    refundTransaction?: {
-      chainId?: number
-      txnHash?: string
-      transactionHash?: string
-    }
-    originChainId?: number
-  },
-): TransactionState[] {
-  if (receipt.status !== "REFUNDED" && !receipt.refundTransaction) {
-    return currentStates
-  }
-
-  const refundChainId =
-    receipt.refundTransaction?.chainId || receipt.originChainId
-  const refundIndex = currentStates.findIndex(
-    (tx) => tx?.chainId === refundChainId,
-  )
-  const targetIndex = refundIndex >= 0 ? refundIndex : 0
-  const targetState = currentStates[targetIndex]
-
-  if (!targetState) {
-    return currentStates
-  }
-
-  const refundHash =
-    receipt.refundTransaction?.txnHash ||
-    receipt.refundTransaction?.transactionHash
-
-  // Check if update is needed
-  const shouldUpdateChainId =
-    !!refundChainId && targetState.refundTransactionChainId !== refundChainId
-  const shouldUpdateHash =
-    !!refundHash && targetState.refundTransactionHash !== refundHash
-
-  if (!targetState.refunded || shouldUpdateChainId || shouldUpdateHash) {
-    return updateTransactionStateAtIndex(currentStates, targetIndex, {
-      refunded: true,
-      refundTransactionChainId: refundChainId,
-      refundTransactionHash: refundHash,
-    })
-  }
-
-  return currentStates
-}
-
-/**
- * Map API TransactionStatus to SDK TransactionStateStatus.
- * SUCCEEDED → "confirmed", failure statuses → "failed", others → "pending"
- */
-function mapRefundStatus(status?: string): TransactionStateStatus {
-  if (status === "SUCCEEDED") {
-    return "confirmed"
-  }
-  if (
-    status === "FAILED" ||
-    status === "ERRORED" ||
-    status === "ABORTED" ||
-    status === "REVERTED"
-  ) {
-    return "failed"
-  }
-  return "pending"
-}
-
-/**
- * Insert a refund transaction state into the transaction states array.
- * The refund is inserted after the last transaction on the same chain.
- */
-export function insertRefundTransactionState(
-  currentStates: TransactionState[],
-  refundTransaction: {
-    chainId?: number
-    txnHash?: string
-    status?: string
-  },
-): TransactionState[] {
-  // Check if refund state already exists
-  const existingRefundIndex = currentStates.findIndex(
-    (tx) => tx.label === "Refund" || tx.id?.includes("refund"),
-  )
-  if (existingRefundIndex >= 0) {
-    // Update existing refund state with new info
-    const existingRefundState = currentStates[existingRefundIndex]
-    const chainIdForExplorer =
-      refundTransaction.chainId ?? existingRefundState?.chainId ?? 0
-    return updateTransactionStateAtIndex(currentStates, existingRefundIndex, {
-      transactionHash: refundTransaction.txnHash,
-      explorerUrl: refundTransaction.txnHash
-        ? getExplorerUrl({
-            txHash: refundTransaction.txnHash,
-            chainId: chainIdForExplorer,
-          })
-        : "",
-      state: mapRefundStatus(refundTransaction.status),
-    })
-  }
-
-  const chainId = refundTransaction.chainId ?? 0
-
-  // Create new refund transaction state
-  const refundState: TransactionState = {
-    id: `refund-${chainId}`,
-    label: "Refund",
-    chainId,
-    transactionHash: refundTransaction.txnHash ?? "",
-    explorerUrl: refundTransaction.txnHash
-      ? getExplorerUrl({ txHash: refundTransaction.txnHash, chainId })
-      : "",
-    state: mapRefundStatus(refundTransaction.status),
-    refunded: true,
-  }
-
-  // Insert after the last transaction on the same chain
-  const newStates = [...currentStates]
-  let insertIndex = newStates.length
-  for (let i = newStates.length - 1; i >= 0; i--) {
-    if (newStates[i]?.chainId === chainId) {
-      insertIndex = i + 1
-      break
-    }
-  }
-  newStates.splice(insertIndex, 0, refundState)
-
-  return newStates
-}

package/src/transactionIntent/index.ts

@@ -1,10 +0,0 @@
-// Re-export all public APIs
-export * from "./types.js"
-export * from "./constants.js"
-export * from "./validators.js"
-export * from "./utils/index.js"
-export * from "./quote/index.js"
-export * from "./execution/index.js"
-export * from "./deposits/index.js"
-export * from "./handlers/index.js"
-export * from "./helpers/index.js"

package/src/transactionIntent/quote/feeExtractors.ts

@@ -1,61 +0,0 @@
-import type { Intent } from "@0xtrails/api"
-import { zeroAddress } from "viem"
-import {
-  formatUsdAmountDisplay,
-  formatUsdAmountLocaleDisplay,
-} from "../../utils/format.js"
-import { logger } from "../../logger.js"
-import type { TradeType, PrepareSendFees } from "../types.js"
-
-export function getFeesFromIntent(
-  intent: Intent,
-  {
-    tradeType,
-    fromAmountUsd,
-    toAmountUsd,
-  }: { tradeType: TradeType; fromAmountUsd: number; toAmountUsd: number },
-): PrepareSendFees {
-  const totalFeeAmountUsd = intent.fees?.totalFeeUsd || 0
-  const totalFeeAmountUsdDisplay = formatUsdAmountDisplay(totalFeeAmountUsd)
-  const totalFeeAmountUsdLocaleDisplay =
-    formatUsdAmountLocaleDisplay(totalFeeAmountUsd)
-
-  logger.console.log("[trails-sdk] getFeesFromIntent", {
-    tradeType,
-    fromAmountUsd,
-    toAmountUsd,
-    totalFeeAmountUsd,
-    totalFeeAmountUsdDisplay,
-    totalFeeAmountUsdLocaleDisplay,
-  })
-
-  return {
-    feeTokenAddress: intent.fees?.feeTokenAddress ?? zeroAddress,
-    totalFeeAmount: intent.fees?.totalFeeAmount?.toString() ?? "0",
-    totalFeeAmountUsd: totalFeeAmountUsd.toString(),
-    totalFeeAmountUsdDisplay,
-    totalFeeAmountUsdLocaleDisplay,
-  }
-}
-
-export function getSlippageToleranceFromIntent(intent: Intent): string {
-  return intent.quote?.maxSlippage?.toString() ?? "0"
-}
-
-export function getPriceImpactFromIntent(intent: Intent): string {
-  return intent?.quote?.priceImpact?.toString() ?? "0"
-}
-
-export function getPriceImpactUsdFromIntent(intent: Intent): string {
-  return intent?.quote?.priceImpactUsd?.toString() ?? "0"
-}
-
-export function getZeroFees(): PrepareSendFees {
-  return {
-    feeTokenAddress: zeroAddress,
-    totalFeeAmount: "0",
-    totalFeeAmountUsd: "0",
-    totalFeeAmountUsdDisplay: formatUsdAmountDisplay(0),
-    totalFeeAmountUsdLocaleDisplay: formatUsdAmountLocaleDisplay(0),
-  }
-}

package/src/transactionIntent/quote/index.ts

@@ -1,3 +0,0 @@
-export * from "./quoteHelpers.js"
-export * from "./feeExtractors.js"
-export * from "./normalizeQuote.js"