@lifi/widget 4.9.0 → 4.10.1

package/src/pages/TransactionPage/utils.ts

@@ -1,3 +1,8 @@
+import { LiFiErrorCode, type RouteExtended } from '@lifi/sdk'
+import { getFailedStepAction } from '../../stores/routes/utils.js'
+import type { WidgetMode } from '../../types/widget.js'
+import { formatTokenAmount } from '../../utils/format.js'
+
 export const calculateValueLossPercentage = (
   fromAmountUSD: number,
   toAmountUSD: number,
@@ -101,3 +106,79 @@ export const getStartGates = (
   ['address', needsAddressConfirmation(input)],
   ['value', input.valueLossExceeded && !input.isCustomMode],
 ]
+
+// Only these modes show the plain from/to swap form.
+const newSwapModes: readonly (WidgetMode | undefined)[] = [
+  undefined,
+  'default',
+  'split',
+]
+
+export const isCallBundleNotFound = (route: RouteExtended): boolean =>
+  getFailedStepAction(route)?.action.error?.code ===
+  LiFiErrorCode.CallBundleNotFound
+
+// A new swap repeats the whole route.
+export const canStartNewSwap = ({
+  route,
+  mode,
+  swapOnly,
+}: {
+  route: RouteExtended
+  mode: WidgetMode | undefined
+  swapOnly: boolean
+}): boolean => {
+  const failed = getFailedStepAction(route)
+  if (!failed || !isCallBundleNotFound(route)) {
+    return false
+  }
+  return (
+    failed.step === route.steps[0] &&
+    route.steps.every(
+      (step) => step === failed.step || !step.execution?.actions?.length
+    ) &&
+    newSwapModes.includes(mode) &&
+    // A swap-only form requests no bridges.
+    !(swapOnly && route.fromChainId !== route.toChainId)
+  )
+}
+
+interface NewSwapFormValues {
+  fromChain: number
+  fromToken: string
+  fromAmount: string
+  toChain: number
+  toToken: string
+  toAddress?: string
+}
+
+export const getNewSwapFormValues = (
+  route: RouteExtended,
+  {
+    keepReceiver = false,
+    receiverRequired = false,
+  }: { keepReceiver?: boolean; receiverRequired?: boolean } = {}
+): NewSwapFormValues => {
+  const receiver = route.toAddress || route.fromAddress
+  const values: NewSwapFormValues = {
+    fromChain: route.fromChainId,
+    fromToken: route.fromToken.address,
+    // The quote's amount, not a step amount trimmed to the balance: the new quote checks it.
+    fromAmount: formatTokenAmount(
+      BigInt(route.fromAmount),
+      route.fromToken.decimals
+    ),
+    toChain: route.toChainId,
+    toToken: route.toToken.address,
+  }
+  if (!keepReceiver) {
+    // A required receiver stays, also when it is the sender.
+    values.toAddress =
+      receiver &&
+      (receiverRequired ||
+        receiver.toLowerCase() !== route.fromAddress?.toLowerCase())
+        ? receiver
+        : ''
+  }
+  return values
+}

package/src/shared.ts

@@ -114,6 +114,7 @@ export { TransactionDoneButtons } from './pages/TransactionPage/TransactionDoneB
 export {
   calculateValueLossPercentage,
   getTokenValueLossThreshold,
+  isCallBundleNotFound,
 } from './pages/TransactionPage/utils.js'
 
 // ── providers ────────────────────────────────────────────────────────────────

package/src/stores/routes/utils.ts

@@ -1,4 +1,9 @@
-import type { ExecutionAction, RouteExtended } from '@lifi/sdk'
+import type {
+  ExecutionAction,
+  ExecutionActionType,
+  LiFiStepExtended,
+  RouteExtended,
+} from '@lifi/sdk'
 import microdiff from 'microdiff'
 
 export const isRouteDone = (route: RouteExtended): boolean => {
@@ -21,6 +26,24 @@ export const isRouteFailed = (route: RouteExtended): boolean => {
   return route.steps.some((step) => step.execution?.status === 'FAILED')
 }
 
+// A step can fail before any action, so its own error then stands in.
+export const getFailedStepAction = (
+  route: RouteExtended
+): { step: LiFiStepExtended; action: ExecutionAction } | undefined => {
+  const step = route.steps.find((step) => step.execution?.status === 'FAILED')
+  if (!step) {
+    return undefined
+  }
+  const action = step.execution?.actions?.find(
+    (action) => action.status === 'FAILED'
+  ) || {
+    status: 'FAILED',
+    type: 'EXECUTION' as ExecutionActionType,
+    error: step.execution?.error,
+  }
+  return { step, action }
+}
+
 export const isRouteActive = (route?: RouteExtended): boolean => {
   if (!route) {
     return false

package/src/utils/getErrorMessage.ts

@@ -130,6 +130,11 @@ export function getErrorMessage(
         chainName: getChainById(step.action.fromChainId)?.name ?? '',
       })
       break
+    // No "remain in your wallet" suffix: the funds may already be gone.
+    case LiFiErrorCode.CallBundleNotFound:
+      title = t('error.title.callBundleNotFound')
+      message = t('error.message.callBundleNotFound')
+      break
     default:
       title = t('error.title.unknown')
       if (failedAction?.txHash) {

package/src/utils/token.ts

@@ -280,6 +280,54 @@ export const getTokenVerificationProvider = (
     : undefined
 }
 
+export type TokenVerificationBadge =
+  | 'native'
+  | 'flagged'
+  | 'verified'
+  | 'unverifiedByProvider'
+  | 'unverified'
+
+export const getTokenVerificationBadge = (
+  token: Pick<
+    TokenWithFlags,
+    'native' | 'listed' | 'verified' | 'verificationStatus'
+  >
+): TokenVerificationBadge | undefined => {
+  // The provider calls the native-address convention a scam on some chains.
+  if (token.native) {
+    return 'native'
+  }
+  if (token.verificationStatus === 'flagged') {
+    return 'flagged'
+  }
+  if (token.verificationStatus === 'verified') {
+    return 'verified'
+  }
+  if (token.listed || token.verified) {
+    return undefined
+  }
+  return token.verificationStatus === 'unverified'
+    ? 'unverifiedByProvider'
+    : 'unverified'
+}
+
+export type TokenStatusTextKey =
+  | 'tokenMetric.statusVerified'
+  | 'tokenMetric.statusFlagged'
+  | 'tokenMetric.statusUnverified'
+
+export const getTokenStatusTextKey = (
+  token: Pick<TokenWithFlags, 'native' | 'verificationStatus'>
+): TokenStatusTextKey => {
+  if (token.verificationStatus === 'verified') {
+    return 'tokenMetric.statusVerified'
+  }
+  if (token.verificationStatus === 'flagged' && !token.native) {
+    return 'tokenMetric.statusFlagged'
+  }
+  return 'tokenMetric.statusUnverified'
+}
+
 /**
  * Hyperliquid declares Arbitrum USDC as its native token, Lighter declares
  * Ethereum USDC. Neither is a gas token you hold there. A chain-local