@lifi/widget 4.8.0 → 4.9.0

package/src/stores/form/FormStore.tsx

@@ -45,6 +45,7 @@ export const FormStoreProvider: React.FC<FormStoreProviderProps> = ({
     toAddress,
     formUpdateKey,
     buildUrl,
+    chains,
   } = widgetConfig
 
   const storeRef = useRef<FormStoreStore>(null)
@@ -113,6 +114,7 @@ export const FormStoreProvider: React.FC<FormStoreProviderProps> = ({
     const queryDefaults = getDefaultValuesFromQueryString({
       buildUrl,
       includeToAddress: false,
+      chains,
     })
     storeRef.current = createFormStore(
       initialiseDefaultValues({

package/src/stores/form/URLSearchParamsBuilder.tsx

@@ -34,16 +34,17 @@ export const URLSearchParamsBuilder = () => {
   const values = useFieldValues(...formValueKeys, ...limitFormValueKeys)
   const { setSelectedBookmark, addRecentWallet } = useBookmarkActions()
   const { validateAddress } = useAddressValidation()
-  const { buildUrl, mode } = useWidgetConfig()
+  const { buildUrl, mode, chains } = useWidgetConfig()
   // Using these methods as trying to use the touchedFields and values above
   // often has a lag that can effect the widgets initialisation sequence
   // and accidentally cause values to be wiped from the query string
   const { getFieldValues, isTouched, setUserAndDefaultValues } =
     useFieldActions()
 
+  // biome-ignore lint/correctness/useExhaustiveDependencies: the URL is read once, not again on each config render
   useEffect(() => {
     // get the initial values from the querystring
-    const formValues = getDefaultValuesFromQueryString({ buildUrl })
+    const formValues = getDefaultValuesFromQueryString({ buildUrl, chains })
     const { toAddress, ...initialFormValues } = formValues
 
     /**
@@ -62,6 +63,7 @@ export const URLSearchParamsBuilder = () => {
             const bookmark = {
               address: validationResult.address,
               chainType: validationResult.chainType,
+              chainId: validationResult.chainId,
             }
             setUserAndDefaultValues({ toAddress })
             setSelectedBookmark(bookmark)

package/src/stores/form/getDefaultValuesFromQueryString.ts

@@ -1,14 +1,21 @@
+import type { WidgetChains } from '../../types/widget.js'
+import {
+  isDestinationOnlyChain,
+  isUnservedDestinationChain,
+} from '../../utils/chainType.js'
 import { formatInputAmount } from '../../utils/format.js'
 import type { DefaultValues } from './types.js'
 
 interface GetDefaultValuesFromQueryStringOptions {
   includeToAddress?: boolean
   buildUrl?: boolean
+  chains?: WidgetChains
 }
 
 export const getDefaultValuesFromQueryString = ({
   buildUrl = false,
   includeToAddress = true,
+  chains,
 }: GetDefaultValuesFromQueryStringOptions): Partial<DefaultValues> => {
   if (typeof window === 'undefined') {
     return {}
@@ -22,6 +29,18 @@ export const getDefaultValuesFromQueryString = ({
     new URLSearchParams(window.location.search)
   )
 
+  // The loop below then drops their tokens too.
+  if (isDestinationOnlyChain(Number.parseInt(searchParams.fromChain, 10))) {
+    delete searchParams.fromChain
+  }
+  if (
+    isUnservedDestinationChain(
+      Number.parseInt(searchParams.toChain, 10),
+      chains
+    )
+  ) {
+    delete searchParams.toChain
+  }
   // Prevent using fromToken/toToken params if chain is not selected.
   ;(['from', 'to'] as const).forEach((key) => {
     if (searchParams[`${key}Token`] && !searchParams[`${key}Chain`]) {

package/src/utils/chainType.ts

@@ -1,4 +1,6 @@
-import { ChainId, ChainType } from '@lifi/sdk'
+import { ChainId, ChainType, type SDKProvider } from '@lifi/sdk'
+import type { WidgetChains, WidgetConfig } from '../types/widget.js'
+import { isItemAllowed } from './item.js'
 
 export const defaultChainIdsByType: Record<ChainType, ChainId> = {
   [ChainType.EVM]: ChainId.ETH,
@@ -8,3 +10,73 @@ export const defaultChainIdsByType: Record<ChainType, ChainId> = {
   [ChainType.TVM]: ChainId.TRN,
   [ChainType.STL]: ChainId.XLM,
 }
+
+// No wallet can sign on these chains yet, so a route may only deliver to them.
+const destinationOnlyChainIds: ReadonlySet<number> = new Set<number>([
+  ChainId.ZEC,
+])
+
+export const isDestinationOnlyChain = (chainId?: number): boolean =>
+  chainId !== undefined && destinationOnlyChainIds.has(chainId)
+
+export const withDestinationOnlyChains = (
+  chains: WidgetChains | undefined
+): WidgetChains => {
+  const allow = chains?.from?.allow?.filter(
+    (chainId) => !isDestinationOnlyChain(chainId)
+  )
+  return {
+    ...chains,
+    from: {
+      ...chains?.from,
+      ...(allow && { allow }),
+      deny: [...(chains?.from?.deny ?? []), ...destinationOnlyChainIds],
+    },
+  }
+}
+
+// A destination-only chain takes a receiver only through a provider that lists it.
+export const withServedDestinationChains = (
+  chains: WidgetChains | undefined,
+  providers: readonly Pick<SDKProvider, 'chainIds'>[]
+): WidgetChains | undefined => {
+  const unserved = [...destinationOnlyChainIds].filter(
+    (chainId) =>
+      !providers.some((provider) =>
+        provider.chainIds?.some((id) => id === chainId)
+      )
+  )
+  if (!unserved.length) {
+    return chains
+  }
+  const allow = chains?.allow?.filter((chainId) => !unserved.includes(chainId))
+  return {
+    ...chains,
+    ...(allow && { allow }),
+    deny: [...(chains?.deny ?? []), ...unserved],
+  }
+}
+
+// The form keeps a preset chain that the chain list does not offer.
+export const isUnservedDestinationChain = (
+  chainId: number | undefined,
+  chains: WidgetChains | undefined
+): boolean => isDestinationOnlyChain(chainId) && !isItemAllowed(chainId, chains)
+
+// Omitted, not undefined: an own undefined key resets the form field.
+export const withoutUnservedToChain = <
+  T extends Pick<WidgetConfig, 'chains' | 'toChain' | 'toToken'>,
+>(
+  config: T
+): T => {
+  if (!isUnservedDestinationChain(config.toChain, config.chains)) {
+    return config
+  }
+  const { toChain: _toChain, toToken: _toToken, ...rest } = config
+  return rest as T
+}
+
+export const isDestinationAllowedAsSource = (
+  toChainId: number | undefined,
+  chains: WidgetChains | undefined
+): boolean => !toChainId || isItemAllowed(toChainId, chains?.from)

package/src/utils/customReceiver.ts

@@ -1,4 +1,5 @@
 import { ChainType } from '@lifi/sdk'
+import type { ChainRef, IsAddressForChain } from '@lifi/widget-provider'
 
 // Stellar routes always settle to the account that signs them.
 export const isCustomReceiverUnsupported = (
@@ -29,3 +30,38 @@ export const isCustomReceiverBlocked = ({
   }
   return toAddress.toLowerCase() !== signerAddress?.toLowerCase()
 }
+
+// Without a receiver the API delivers to the signer when both chains share a
+// chain type, and a Bitcoin signer cannot receive on ZEC.
+export const isSignerInvalidReceiver = ({
+  signerAddress,
+  toAddress,
+  fromChain,
+  toChain,
+  isAddressForChain,
+}: {
+  signerAddress: string | undefined
+  toAddress: string | undefined
+  fromChain: ChainRef | undefined
+  toChain: ChainRef | undefined
+  isAddressForChain: IsAddressForChain
+}): boolean =>
+  Boolean(
+    signerAddress &&
+      !toAddress &&
+      fromChain &&
+      toChain &&
+      fromChain.chainType === toChain.chainType &&
+      !isAddressForChain(signerAddress, toChain)
+  )
+
+export const canQuoteWithToAddress = (
+  toAddress: string | undefined,
+  toChain: ChainRef | undefined,
+  isAddressForChain: IsAddressForChain
+): boolean => {
+  if (!toAddress) {
+    return true
+  }
+  return toChain ? isAddressForChain(toAddress, toChain) : false
+}