@rango-dev/widget-embedded 0.0.0-experimental-936229e8-20251208

package/src/utils/quote.ts

@@ -0,0 +1,404 @@
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+import type { RetryQuote } from '../store/quote';
+import type { FindToken } from '../store/slices/data';
+import type { QuoteWarning, SelectedQuote, Wallet } from '../types';
+import type {
+  PriceImpactWarningLevel,
+  SimulationAssetAndAmount,
+  SimulationValidationStatus,
+  Step,
+} from '@rango-dev/ui';
+import type {
+  Asset,
+  BlockchainMeta,
+  MultiRouteResponse,
+  MultiRouteSimulationResult,
+  PreferenceType,
+  RouteTag,
+} from 'rango-sdk';
+import type { PendingSwap } from 'rango-types';
+
+import { getLastSuccessfulStep } from '@rango-dev/queue-manager-rango-preset';
+import BigNumber from 'bignumber.js';
+
+import { HIGH_PRIORITY_TAGS } from '../constants/quote';
+import { HIGHT_PRICE_IMPACT, LOW_PRICE_IMPACT } from '../constants/routing';
+import { HIGH_SLIPPAGE } from '../constants/swapSettings';
+import { QuoteWarningType } from '../types';
+
+import { areEqual } from './common';
+import { createTokenHash, findBlockchain } from './meta';
+import { numberToString } from './numbers';
+import {
+  checkSlippageWarnings,
+  getMinRequiredSlippage,
+  getPercentageChange,
+  getTotalFeeInUsd,
+  getUsdInputFrom,
+  getUsdOutputFrom,
+  hasHighValueLoss,
+  hasProperSlippage,
+  isOutputAmountChangedExcessively,
+} from './swap';
+
+export function isNumberOfSwapsChanged(
+  quoteA: SelectedQuote,
+  quoteB: SelectedQuote
+) {
+  const quoteASwaps = quoteA?.swaps || [];
+  const quoteBSwaps = quoteB?.swaps || [];
+  return quoteASwaps.length !== quoteBSwaps.length;
+}
+
+export function isQuoteSwappersUpdated(
+  quoteA: SelectedQuote,
+  quoteB: SelectedQuote
+) {
+  const quoteASwappers = quoteA?.swaps.map((swap) => swap.swapperId) || [];
+  const quoteBSwappers = quoteB?.swaps.map((swap) => swap.swapperId) || [];
+  return !areEqual(quoteASwappers, quoteBSwappers);
+}
+
+export function isQuoteInternalCoinsUpdated(
+  quoteA: SelectedQuote,
+  quoteB: SelectedQuote
+) {
+  const quoteAInternalCoins = quoteA?.swaps.map((swap) => swap.to.symbol) || [];
+  const quoteBInternalCoins = quoteB?.swaps.map((swap) => swap.to.symbol) || [];
+  return !areEqual(quoteAInternalCoins, quoteBInternalCoins);
+}
+
+export function isQuoteChanged(
+  quoteA: SelectedQuote,
+  quoteB: SelectedQuote
+): boolean {
+  return (
+    isNumberOfSwapsChanged(quoteA, quoteB) ||
+    isQuoteSwappersUpdated(quoteA, quoteB) ||
+    isQuoteInternalCoinsUpdated(quoteA, quoteB)
+  );
+}
+
+export function outToRatioHasWarning(
+  fromUsdValue: BigNumber | null,
+  outToInRatio: BigNumber | 0
+) {
+  return (
+    (parseInt(outToInRatio?.toFixed(2) || '0') <= -10 &&
+      (fromUsdValue === null || fromUsdValue.gte(new BigNumber(200)))) ||
+    (parseInt(outToInRatio?.toFixed(2) || '0') <= -5 &&
+      (fromUsdValue === null || fromUsdValue.gte(new BigNumber(1000))))
+  );
+}
+
+export function getRequiredBalanceOfWallet(
+  selectedWallet: Wallet,
+  fee: SimulationValidationStatus[] | null
+): SimulationAssetAndAmount[] | null {
+  if (fee === null) {
+    return null;
+  }
+  const relatedFeeStatus = fee
+    ?.find((item) => item.blockchain === selectedWallet.chain)
+    ?.wallets.find(
+      (wallet) =>
+        wallet.address?.toLowerCase() === selectedWallet.address.toLowerCase()
+    );
+  if (!relatedFeeStatus) {
+    return null;
+  }
+  return relatedFeeStatus.requiredAssets;
+}
+
+export function getPriceImpactLevel(
+  priceImpact: number
+): PriceImpactWarningLevel {
+  let warningLevel: PriceImpactWarningLevel = undefined;
+  if (priceImpact <= LOW_PRICE_IMPACT && priceImpact > HIGHT_PRICE_IMPACT) {
+    warningLevel = 'low';
+  } else if (priceImpact <= HIGHT_PRICE_IMPACT) {
+    warningLevel = 'high';
+  }
+
+  return warningLevel;
+}
+
+export function findCommonTokens<T extends Asset[], R extends Asset[]>(
+  listA: T,
+  listB: R
+) {
+  const set = new Set();
+
+  listA.forEach((token) => set.add(createTokenHash(token)));
+
+  return listB.filter((token) => set.has(createTokenHash(token))) as R;
+}
+
+export function createRetryQuote(
+  pendingSwap: PendingSwap,
+  blockchains: BlockchainMeta[],
+  findToken: FindToken
+): RetryQuote {
+  const firstStep = pendingSwap.steps[0];
+  const lastStep = pendingSwap.steps[pendingSwap.steps.length - 1];
+  const lastSuccessfulStep = getLastSuccessfulStep(pendingSwap.steps);
+
+  if (!lastStep || !firstStep) {
+    return {
+      fromBlockchain: null,
+      fromToken: undefined,
+      toBlockchain: null,
+      toToken: undefined,
+      inputAmount: '',
+    };
+  }
+
+  const toToken = {
+    blockchain: lastStep.toBlockchain,
+    symbol: lastStep.toSymbol,
+    address: lastStep.toSymbolAddress,
+  };
+
+  const fromBlockchainMeta = findBlockchain(
+    lastSuccessfulStep
+      ? lastSuccessfulStep.toBlockchain
+      : firstStep.fromBlockchain,
+    blockchains
+  );
+  const toBlockchainMeta = findBlockchain(lastStep.toBlockchain, blockchains);
+  const fromTokenMeta = findToken(
+    lastSuccessfulStep
+      ? {
+          blockchain: fromBlockchainMeta?.name ?? '',
+          symbol: lastSuccessfulStep.toSymbol,
+          address: lastSuccessfulStep.toSymbolAddress,
+        }
+      : {
+          blockchain: fromBlockchainMeta?.name ?? '',
+          symbol: firstStep.fromSymbol,
+          address: firstStep.fromSymbolAddress,
+        }
+  );
+  const toTokenMeta = findToken(toToken);
+  const inputAmount = lastSuccessfulStep
+    ? lastSuccessfulStep.outputAmount ?? ''
+    : pendingSwap.inputAmount;
+
+  return {
+    fromBlockchain: fromBlockchainMeta,
+    fromToken: fromTokenMeta,
+    toBlockchain: toBlockchainMeta,
+    toToken: toTokenMeta,
+    inputAmount,
+  };
+}
+
+export function generateQuoteWarnings(params: {
+  previousQuote?: SelectedQuote;
+  currentQuote: SelectedQuote;
+  findToken: FindToken;
+  userSlippage: number;
+}): QuoteWarning | null {
+  const { previousQuote, currentQuote, findToken, userSlippage } = params;
+  const usdInput = getUsdInputFrom(currentQuote);
+  const usdOutput = getUsdOutputFrom(currentQuote);
+
+  if (!!currentQuote && usdInput && usdOutput) {
+    const priceImpact = getPriceImpact(
+      usdInput.toString(),
+      usdOutput.toString()
+    );
+    const highValueLoss =
+      !!priceImpact && hasHighValueLoss(usdInput, priceImpact);
+
+    if (highValueLoss) {
+      const totalFee = getTotalFeeInUsd(currentQuote?.swaps, findToken);
+      const warningLevel = getPriceImpactLevel(priceImpact);
+      return {
+        type: QuoteWarningType.HIGH_VALUE_LOSS,
+        inputUsdValue: usdInput,
+        outputUsdValue: usdOutput,
+        priceImpact,
+        totalFee,
+        warningLevel,
+      };
+    }
+  }
+
+  if (
+    previousQuote &&
+    isOutputAmountChangedExcessively(previousQuote, currentQuote)
+  ) {
+    return {
+      type: QuoteWarningType.EXCESSIVE_OUTPUT_AMOUNT_CHANGE,
+      usdValueChange: numberToString(
+        getUsdOutputFrom(currentQuote)
+          ?.minus(getUsdOutputFrom(previousQuote) ?? 0)
+          .toString() ?? '0',
+        null,
+        2
+      ),
+      percentageChange: numberToString(
+        getPriceImpact(
+          getUsdOutputFrom(previousQuote) ?? '1',
+          getUsdOutputFrom(currentQuote) ?? '1'
+        ),
+        null,
+        2
+      ),
+    };
+  }
+
+  if (currentQuote && (!usdInput || !usdOutput)) {
+    return { type: QuoteWarningType.UNKNOWN_PRICE };
+  }
+
+  const minRequiredSlippage = getMinRequiredSlippage(currentQuote.swaps);
+  const highSlippage = userSlippage > HIGH_SLIPPAGE;
+
+  if (!hasProperSlippage(params.userSlippage.toString(), minRequiredSlippage)) {
+    return {
+      type: QuoteWarningType.INSUFFICIENT_SLIPPAGE,
+      recommendedSlippages: checkSlippageWarnings(currentQuote, userSlippage),
+      minRequiredSlippage: minRequiredSlippage,
+    };
+  } else if (
+    highSlippage &&
+    parseFloat(minRequiredSlippage ?? '0') < userSlippage
+  ) {
+    return {
+      type: QuoteWarningType.HIGH_SLIPPAGE,
+      slippage: userSlippage.toString(),
+    };
+  }
+
+  return null;
+}
+
+export function isQuoteWarningConfirmationRequired(warning: QuoteWarning) {
+  const WARNINGS_NOT_REQUIRING_CONFIRMATION = [
+    QuoteWarningType.EXCESSIVE_OUTPUT_AMOUNT_CHANGE,
+  ];
+  return !WARNINGS_NOT_REQUIRING_CONFIRMATION.includes(warning.type);
+}
+
+export function getPriceImpact(
+  inputUsdValue: BigNumber | string | null,
+  outputUsdValue: BigNumber | string | null
+): number | null {
+  const outputUsdValueIsInvalid =
+    typeof outputUsdValue === 'string'
+      ? parseFloat(outputUsdValue) <= 0
+      : !outputUsdValue?.gt(0);
+  const percentageChange =
+    !inputUsdValue || !outputUsdValue || outputUsdValueIsInvalid
+      ? null
+      : getPercentageChange(
+          inputUsdValue.toString(),
+          outputUsdValue.toString()
+        );
+
+  return percentageChange && percentageChange < 0 ? percentageChange : null;
+}
+
+export const getUniqueBlockchains = (steps: Step[]) => {
+  const set = new Set();
+  const result: { displayName: string; image?: string }[] = [];
+  steps.forEach((step) => {
+    if (!set.has(step.from.chain.displayName)) {
+      set.add(step.from.chain.displayName);
+      result.push(step.from.chain);
+    }
+    if (!set.has(step.to.chain.displayName)) {
+      set.add(step.to.chain.displayName);
+      result.push(step.to.chain);
+    }
+  });
+
+  return result;
+};
+
+export const sortQuotesBy = (
+  strategy: PreferenceType,
+  quotes: MultiRouteResponse['results']
+): MultiRouteResponse['results'] => {
+  return quotes.sort((quote1, quote2) => {
+    const getScore = (route: MultiRouteSimulationResult) =>
+      route.scores?.find((score) => score.preferenceType === strategy)?.score ??
+      0;
+
+    const quote1Score = getScore(quote1);
+    const quote2Score = getScore(quote2);
+
+    if (quote1Score !== quote2Score) {
+      return quote2Score - quote1Score;
+    }
+
+    const lowerQuoteId1 = quote1.requestId.toLowerCase();
+    const lowerQuoteId2 = quote2.requestId.toLowerCase();
+
+    return lowerQuoteId1.localeCompare(lowerQuoteId2);
+  });
+};
+
+export const getDefaultQuote = (
+  currentQuote: SelectedQuote | null,
+  quotes: MultiRouteSimulationResult[],
+  requestAmount: string
+): SelectedQuote | null => {
+  const quote = quotes[0]; // Return the first quote from the quotes array
+  if (!quotes.length || !quote) {
+    return null;
+  }
+  if (!currentQuote) {
+    // Handle the case where currentQuote is null
+    return {
+      requestAmount,
+      validationStatus: null,
+      ...quote,
+    };
+  }
+  // Create a set of swapperIds from the currentQuote swaps
+  const currentQuoteSwapperIds = new Set(
+    currentQuote.swaps.map((swap) => swap.swapperId)
+  );
+
+  // Find a quote that matches the currentQuote's swapperIds
+  const matchedQuote = quotes.find((quote) => {
+    // Create a set of swapperIds from the quote swaps
+    const quoteSwapperIds = new Set(quote.swaps.map((swap) => swap.swapperId));
+
+    // Check if all swapperIds from the currentQuote are present in the quoteSwapperIds
+    return Array.from(currentQuoteSwapperIds).every((swapperId) =>
+      quoteSwapperIds.has(swapperId)
+    );
+  });
+
+  // Return the matchedQuote if found, otherwise return the first quote from the quotes array
+  return {
+    requestAmount,
+    validationStatus: null,
+    ...(matchedQuote || quote),
+  };
+};
+
+export const sortTags = (tags: RouteTag[]): RouteTag[] => {
+  const customSort = (a: RouteTag, b: RouteTag) => {
+    const indexA = HIGH_PRIORITY_TAGS.indexOf(a.value);
+    const indexB = HIGH_PRIORITY_TAGS.indexOf(b.value);
+
+    if (indexA !== -1 && indexB !== -1) {
+      return indexA - indexB;
+    }
+
+    if (indexA !== -1) {
+      return -1;
+    } else if (indexB !== -1) {
+      return 1;
+    }
+
+    return 0;
+  };
+
+  return tags.sort(customSort);
+};

package/src/utils/sanitizers.test.ts

@@ -0,0 +1,122 @@
+import { faker } from '@faker-js/faker';
+import { describe, expect, test } from 'vitest';
+
+import {
+  ensureLeadingZeroForDecimal,
+  formatThousandsWithCommas,
+  removeLeadingZeros,
+  replaceSpacesWithDash,
+  stripTrailingZeros,
+} from './sanitizers';
+
+const WORD_COUNT = 5;
+const FAKER_SEED = 12;
+const LONG_NUMBER_LENGTH = 50;
+faker.seed(FAKER_SEED);
+
+describe('check sanitization behaviors', () => {
+  describe('check leading zero removal', () => {
+    test('should remove zeros at start before digits', () => {
+      expect(removeLeadingZeros('000123')).toBe('123');
+      expect(removeLeadingZeros('00123')).toBe('123');
+    });
+
+    test('should preserve lone zero or non-digit prefixes', () => {
+      expect(removeLeadingZeros('0')).toBe('0');
+      expect(removeLeadingZeros('0000')).toBe('0');
+      expect(removeLeadingZeros('00.1')).toBe('0.1');
+      expect(removeLeadingZeros('00a')).toBe('0a');
+    });
+
+    test('should leave strings with no leading zeros unchanged', () => {
+      const val = faker.number.int({ min: 1, max: 999 }).toString();
+      expect(removeLeadingZeros(val)).toBe(val);
+    });
+  });
+
+  describe('check decimal leading zero insertion', () => {
+    test('should add a zero before lone decimal points', () => {
+      expect(ensureLeadingZeroForDecimal('.5')).toBe('0.5');
+      expect(ensureLeadingZeroForDecimal('.000')).toBe('0.000');
+      expect(ensureLeadingZeroForDecimal('0.001')).toBe('0.001');
+      expect(ensureLeadingZeroForDecimal('000.000')).toBe('000.000');
+    });
+
+    test('should not alter other inputs', () => {
+      expect(ensureLeadingZeroForDecimal('0.5')).toBe('0.5');
+      expect(ensureLeadingZeroForDecimal('2.')).toBe('2.');
+      expect(ensureLeadingZeroForDecimal('')).toBe('');
+    });
+  });
+
+  describe('check thousand separator formatting', () => {
+    test('should insert commas every three digits for 4–6 digit numbers', () => {
+      expect(formatThousandsWithCommas('1000')).toBe('1,000');
+      expect(formatThousandsWithCommas('12345')).toBe('12,345');
+      expect(formatThousandsWithCommas('123456')).toBe('123,456');
+    });
+
+    test('should handle large numbers correctly', () => {
+      expect(formatThousandsWithCommas('1234567')).toBe('1,234,567');
+      expect(formatThousandsWithCommas('1234567890')).toBe('1,234,567,890');
+    });
+
+    test('should not add commas for numbers below 1000', () => {
+      expect(formatThousandsWithCommas('0')).toBe('0');
+      expect(formatThousandsWithCommas('999')).toBe('999');
+    });
+  });
+
+  describe('check space-to-dash replacement', () => {
+    test('should convert any spaces to a single dash', () => {
+      const words = faker.lorem.words(WORD_COUNT).split(' ');
+      const spaced = words.join('   ');
+      expect(replaceSpacesWithDash(spaced)).toBe(words.join('-'));
+    });
+
+    test('should convert tabs and newlines into dashes', () => {
+      const words = faker.lorem.words(WORD_COUNT).split(' ');
+      expect(replaceSpacesWithDash(words.join('\t'))).toBe(words.join('-'));
+      expect(replaceSpacesWithDash(words.join('\n'))).toBe(words.join('-'));
+    });
+
+    test('should handle empty or single-word strings', () => {
+      expect(replaceSpacesWithDash('')).toBe('');
+      expect(replaceSpacesWithDash('nospace')).toBe('nospace');
+    });
+  });
+
+  describe('check trailing zero stripping', () => {
+    test('should trim only zeros after last non-zero digit', () => {
+      expect(stripTrailingZeros('0.0010000')).toBe('0.001');
+      expect(stripTrailingZeros('123.45000')).toBe('123.45');
+      expect(stripTrailingZeros('5.1000')).toBe('5.1');
+    });
+
+    test('should remove entire fractional part if all zeros', () => {
+      expect(stripTrailingZeros('10.000')).toBe('10');
+      expect(stripTrailingZeros('0.000')).toBe('0');
+    });
+
+    test('should leave inputs without trailing zeros untouched', () => {
+      expect(stripTrailingZeros('42')).toBe('42');
+      expect(stripTrailingZeros('7.89')).toBe('7.89');
+      expect(stripTrailingZeros('0.123')).toBe('0.123');
+    });
+
+    test('edge: very long fractional zeros', () => {
+      const long =
+        '0.' +
+        '0'.repeat(LONG_NUMBER_LENGTH) +
+        '1' +
+        '0'.repeat(LONG_NUMBER_LENGTH);
+      expect(stripTrailingZeros(long)).toBe(
+        '0.' + '0'.repeat(LONG_NUMBER_LENGTH) + '1'
+      );
+    });
+
+    test('edge: no decimal point', () => {
+      expect(stripTrailingZeros('1000')).toBe('1000');
+    });
+  });
+});

package/src/utils/sanitizers.ts

@@ -0,0 +1,41 @@
+/**
+ * Remove leading zeros when followed by another digit.
+ * @example "000123" → "123"
+ */
+export function removeLeadingZeros(input: string): string {
+  return input.replace(/^0+(?=\d)/g, '');
+}
+
+/**
+ * Ensure a leading zero before a decimal point.
+ * @example ".45" → "0.45"
+ */
+export function ensureLeadingZeroForDecimal(input: string): string {
+  return input.replace(/^\.(\d+)/, '0.$1');
+}
+
+/**
+ * Insert commas as thousand separators.
+ * @example "1234567" → "1,234,567"
+ */
+export function formatThousandsWithCommas(input: string): string {
+  return input.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+
+/**
+ * Replace spaces (one or more) with a single dash.
+ * @example "a b  c" → "a-b-c"
+ */
+export function replaceSpacesWithDash(input: string): string {
+  return input.replace(/\s+/g, '-');
+}
+
+/**
+ * Strip any trailing zeros in the fractional part, and remove a dangling decimal point.
+ * @example "0.0010000" → "0.001"
+ * @example "10.000"    → "10"
+ */
+export function stripTrailingZeros(input: string): string {
+  const s = input.replace(/(\.\d*?[1-9])0+$/, '$1');
+  return s.replace(/\.0+$/, '');
+}

package/src/utils/settings.ts

@@ -0,0 +1,124 @@
+import type { Features, HighSlippageWarning, Routing } from '../types';
+import type { SwapperMeta, SwapperType, Token } from 'rango-sdk';
+
+import { i18n } from '@lingui/core';
+
+import {
+  HIGH_SLIPPAGE,
+  MAX_SLIPPAGE,
+  MIN_SLIPPAGE,
+} from '../constants/swapSettings';
+import { QuoteWarningType } from '../types';
+
+import { removeDuplicateFrom } from './common';
+
+export type UniqueSwappersGroupType = {
+  id: string;
+  groupTitle: string;
+  logo: string;
+  type: SwapperType;
+  selected: boolean;
+};
+
+export function getUniqueSwappersGroups(
+  swappers: SwapperMeta[],
+  disabledLiquiditySources: string[]
+): UniqueSwappersGroupType[] {
+  const supportedSwappers = swappers.map((swapper) => swapper.swapperGroup);
+
+  const uniqueSupportedSwappersGroups: Array<UniqueSwappersGroupType> = [];
+
+  const uniqueGroup = removeDuplicateFrom(swappers.map((s) => s.swapperGroup));
+
+  uniqueGroup.map((uniqueGroupItem) => {
+    const swapperItem = swappers.find(
+      (swapper) => swapper.swapperGroup === uniqueGroupItem
+    );
+
+    if (swapperItem) {
+      let isSupportedSwapper = true;
+      if (supportedSwappers) {
+        isSupportedSwapper = supportedSwappers.some(
+          (supportedItem) => supportedItem === swapperItem.swapperGroup
+        );
+      }
+
+      if (isSupportedSwapper) {
+        swapperItem.types.map((swapperTypeItem) => {
+          uniqueSupportedSwappersGroups.push({
+            id: swapperItem.swapperGroup,
+            groupTitle: swapperItem.swapperGroup,
+            logo: swapperItem.logo,
+            type: swapperTypeItem,
+            selected: !disabledLiquiditySources.includes(
+              swapperItem.swapperGroup
+            ),
+          });
+        });
+      }
+    }
+  });
+
+  return uniqueSupportedSwappersGroups;
+}
+
+export function sortLiquiditySourcesByGroupTitle(
+  a: SwapperMeta,
+  b: SwapperMeta
+) {
+  if (a.swapperGroup < b.swapperGroup) {
+    return -1;
+  }
+
+  if (a.swapperGroup > b.swapperGroup) {
+    return 1;
+  }
+
+  return 0;
+}
+
+export function isFeatureHidden(feature: keyof Features, features?: Features) {
+  return features?.[feature] === 'hidden';
+}
+
+export function isRoutingEnabled(item: keyof Routing, routing?: Routing) {
+  return routing?.[item] === 'enabled';
+}
+
+export const addCustomTokensToSupportedTokens = (
+  supportedTokens: Token[],
+  customTokens: Token[],
+  features?: Features
+) => {
+  const isCustomTokensHidden = isFeatureHidden('customTokens', features);
+
+  return isCustomTokensHidden
+    ? supportedTokens
+    : supportedTokens.concat(customTokens);
+};
+
+export function getSlippageValidation(slippage: number): {
+  type: 'error' | 'warning';
+  message: string;
+  quoteValidation?: HighSlippageWarning;
+} | null {
+  if (slippage == MIN_SLIPPAGE) {
+    return {
+      type: 'error',
+      message: i18n.t('Slippage must be greater than or equal to 0.01'),
+    };
+  } else if (slippage > HIGH_SLIPPAGE && slippage <= MAX_SLIPPAGE) {
+    return {
+      type: 'warning',
+      message: i18n.t(
+        'Your transaction is at risk of being frontrun due to high slippage tolerance.'
+      ),
+      quoteValidation: {
+        type: QuoteWarningType.HIGH_SLIPPAGE,
+        slippage: slippage.toString(),
+      },
+    };
+  }
+
+  return null;
+}