@rango-dev/widget-embedded 0.47.1-next.0 → 0.47.1-next.2

package/src/store/slices/wallets.ts

@@ -339,7 +339,9 @@ export const createWalletsSlice = keepLastUpdated<AppStoreState, WalletsSlice>(
           if (!acc[wallet.address]) {
             acc[wallet.address] = [];
           }
-          acc[wallet.address].push(...tokensByBlockchain[wallet.chain]);
+          acc[wallet.address]?.push(
+            ...(tokensByBlockchain[wallet.chain] || [])
+          );
         }
         return acc;
       }, {});
@@ -442,9 +444,13 @@ export const createWalletsSlice = keepLastUpdated<AppStoreState, WalletsSlice>(
       });
     },
     newWalletConnected: async (accounts, namespace, derivationPath) => {
+      const newAccount = accounts[0];
+      if (!newAccount) {
+        return;
+      }
       eventEmitter.emit(WidgetEvents.WalletEvent, {
         type: WalletEventTypes.CONNECT,
-        payload: { walletType: accounts[0].walletType, accounts },
+        payload: { walletType: newAccount.walletType, accounts },
       });
 
       get().addConnectedWallet(accounts, namespace, derivationPath);
@@ -602,7 +608,7 @@ export const createWalletsSlice = keepLastUpdated<AppStoreState, WalletsSlice>(
       }
     },
     fetchMainTokensBalances: async (accounts, options) => {
-      if (accounts.length === 0) {
+      if (accounts.length === 0 || !accounts[0]) {
         return;
       }
       // All the `accounts` have same `walletType` so we can pick the first one.
@@ -744,18 +750,25 @@ export const createWalletsSlice = keepLastUpdated<AppStoreState, WalletsSlice>(
       const assetKey = createAssetKey(token);
       const targetBalanceKeys = get()._aggregatedBalances[assetKey] || [];
 
-      if (targetBalanceKeys.length === 0) {
+      if (targetBalanceKeys.length === 0 || !targetBalanceKeys[0]) {
         return null;
-      } else if (targetBalanceKeys.length === 1) {
-        const targetKey = targetBalanceKeys[0];
+      }
+      const targetKey = targetBalanceKeys[0];
+      if (targetBalanceKeys.length === 1 && balances[targetKey]) {
         return balances[targetKey];
       }
 
       // If there are multiple balances for an specific token, we pick the maximum.
       const firstTargetBalance = balances[targetBalanceKeys[0]];
+      if (!firstTargetBalance) {
+        return null;
+      }
       let maxBalance: Balance = firstTargetBalance;
       targetBalanceKeys.forEach((targetBalanceKey) => {
         const currentBalance = balances[targetBalanceKey];
+        if (!currentBalance) {
+          return;
+        }
         const currentBalanceAmount = new BigNumber(currentBalance.amount);
         const prevBalanceAmount = new BigNumber(maxBalance.amount);
 
@@ -775,7 +788,7 @@ export const createWalletsSlice = keepLastUpdated<AppStoreState, WalletsSlice>(
 
           const [, , , balanceWalletAddreess] =
             balanceKey.split(BALANCE_SEPARATOR);
-          if (balanceWalletAddreess === address) {
+          if (balance && balanceWalletAddreess === address) {
             output[balanceKey] = balance;
           }
 
@@ -799,10 +812,10 @@ export const createWalletsSlice = keepLastUpdated<AppStoreState, WalletsSlice>(
               const balance = balances[balanceKey];
               const asset = extractAssetFromBalanceKey(balanceKey);
 
-              if (asset.blockchain === wallet.chain) {
+              if (asset && asset.blockchain === wallet.chain && balance) {
                 const token = get().findToken(asset);
 
-                const amount = balance.amount
+                const amount = balance?.amount
                   ? new BigNumber(balance.amount).shiftedBy(-balance.decimals)
                   : ZERO;
 

package/src/store/utils/data.test.ts

@@ -1,6 +1,6 @@
 import type { Token } from 'rango-sdk';
 
-import { describe, expect, test } from 'vitest';
+import { beforeEach, describe, expect, test } from 'vitest';
 
 import { createToken } from '../../test-utils/fixtures';
 import { createTokenHash } from '../../utils/meta';
@@ -35,25 +35,38 @@ function createMetaForMockData(
     if (!meta.tokensMapByBlockchainName[token.blockchain]) {
       meta.tokensMapByBlockchainName[token.blockchain] = [];
     }
-    meta.tokensMapByBlockchainName[token.blockchain].push(tokenHash);
+    meta.tokensMapByBlockchainName[token.blockchain]?.push(tokenHash);
   });
 
   return meta;
 }
 
 describe('matchTokensFromConfigWithMeta', () => {
+  let token0: Token;
+  let token1: Token;
+  let token2: Token;
+
+  beforeEach(() => {
+    // Assert presence once
+    if (!tokens[0] || !tokens[1] || !tokens[2]) {
+      throw new Error('Test data not populated correctly');
+    }
+    token0 = tokens[0];
+    token1 = tokens[1];
+    token2 = tokens[2];
+  });
   test('should include tokens from config.tokens array that exist in meta', () => {
     const mockData: MatchTokensFromConfigWithMetaParam = {
       type: 'source',
       meta: createMetaForMockData(tokens),
       config: {
         blockchains: undefined,
-        tokens: [tokens[0], tokens[1]],
+        tokens: [token0, token1],
       },
     };
 
     const result = matchTokensFromConfigWithMeta(mockData);
-    expect(result).toEqual([tokens[0], tokens[1]]);
+    expect(result).toEqual([token0, token1]);
   });
 
   test('If config.blockchains is not defined or is empty, we should include all tokens from the meta for every blockchain that does not have tokens specified in the config, as well as tokens specified in the config that exist in the meta.', () => {
@@ -63,7 +76,7 @@ describe('matchTokensFromConfigWithMeta', () => {
       config: {
         blockchains: undefined,
         tokens: {
-          [BLOCKCHAIN_A]: { tokens: [tokens[0]], isExcluded: false },
+          [BLOCKCHAIN_A]: { tokens: [token0], isExcluded: false },
         },
       },
     };
@@ -80,7 +93,7 @@ describe('matchTokensFromConfigWithMeta', () => {
        * as we have a comprehensive sorting logic applied to tokens within the data slice.
        */
       // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-      expect(result).toEqual([tokens[2], tokens[3], tokens[0]]);
+      expect(result).toEqual([token2, tokens[3], token0]);
     };
 
     runTestWithConfig({ blockchains: undefined });
@@ -94,14 +107,14 @@ describe('matchTokensFromConfigWithMeta', () => {
       config: {
         blockchains: [BLOCKCHAIN_A, BLOCKCHAIN_B],
         tokens: {
-          [BLOCKCHAIN_A]: { tokens: [tokens[0]], isExcluded: false },
-          [BLOCKCHAIN_B]: { tokens: [tokens[2]], isExcluded: false },
+          [BLOCKCHAIN_A]: { tokens: [token0], isExcluded: false },
+          [BLOCKCHAIN_B]: { tokens: [token2], isExcluded: false },
         },
       },
     };
 
     const result = matchTokensFromConfigWithMeta(mockData);
-    expect(result).toEqual([tokens[0], tokens[2]]);
+    expect(result).toEqual([token0, token2]);
   });
 
   test('should not include tokens from config.tokens whose blockchain does not exist in config.blockchains', () => {
@@ -111,13 +124,13 @@ describe('matchTokensFromConfigWithMeta', () => {
       config: {
         blockchains: [BLOCKCHAIN_A],
         tokens: {
-          [BLOCKCHAIN_B]: { tokens: [tokens[2]], isExcluded: false },
+          [BLOCKCHAIN_B]: { tokens: [token2], isExcluded: false },
         },
       },
     };
 
     const result = matchTokensFromConfigWithMeta(mockData);
-    expect(result).toEqual([tokens[0], tokens[1]]);
+    expect(result).toEqual([token0, token1]);
   });
 
   test('should include all tokens from a blockchain if that blockchain does not have any tokens in config.tokens', () => {
@@ -131,7 +144,7 @@ describe('matchTokensFromConfigWithMeta', () => {
     };
 
     const result = matchTokensFromConfigWithMeta(mockData);
-    expect(result).toEqual([tokens[0], tokens[1]]);
+    expect(result).toEqual([token0, token1]);
   });
 
   test('should include all tokens from config.blockchains that exist in the meta, except tokens excluded in config.token', () => {
@@ -141,13 +154,13 @@ describe('matchTokensFromConfigWithMeta', () => {
       config: {
         blockchains: [BLOCKCHAIN_A],
         tokens: {
-          [BLOCKCHAIN_A]: { tokens: [tokens[0]], isExcluded: true },
+          [BLOCKCHAIN_A]: { tokens: [token0], isExcluded: true },
         },
       },
     };
 
     const result = matchTokensFromConfigWithMeta(mockData);
-    expect(result).toEqual([tokens[1]]);
+    expect(result).toEqual([token1]);
   });
 
   test('should include all tokens from the meta when config parameters are empty values', () => {

package/src/store/utils/data.ts

@@ -78,8 +78,13 @@ export function matchTokensFromConfigWithMeta(params: {
     const configBlockchainsSet = new Set(configBlockchains);
 
     Object.keys(meta.tokensMapByBlockchainName).forEach((blockchain) => {
-      if (!configBlockchainsSet.has(blockchain)) {
-        addTokens(meta.tokensMapByBlockchainName[blockchain]);
+      const metaTokensForSelectedBlockchain =
+        meta.tokensMapByBlockchainName[blockchain];
+      if (
+        !configBlockchainsSet.has(blockchain) &&
+        metaTokensForSelectedBlockchain
+      ) {
+        addTokens(metaTokensForSelectedBlockchain);
       }
     });
   }
@@ -99,7 +104,10 @@ export function matchTokensFromConfigWithMeta(params: {
     }
 
     if (targetTokensForBlockchain) {
-      if (targetTokensForBlockchain.isExcluded) {
+      if (
+        targetTokensForBlockchain.isExcluded &&
+        meta.tokensMapByBlockchainName[blockchain]
+      ) {
         /**
          * If tokens are excluded,
          * we first include all tokens from the meta for that blockchain,

package/src/store/utils/wallets.ts

@@ -35,9 +35,13 @@ export function createBalanceKey(
   return `${assetKey}${BALANCE_SEPARATOR}${accountAddress}`;
 }
 
-export function extractAssetFromBalanceKey(key: BalanceKey): Asset {
+export function extractAssetFromBalanceKey(key: BalanceKey): Asset | null {
   const [assetChain, assetAddress, assetSymbol] = key.split(BALANCE_SEPARATOR);
 
+  if (!assetChain || !assetAddress || !assetSymbol) {
+    return null;
+  }
+
   // null will be serialized to 'null', we need to make it back to a null type
   const address = assetAddress === 'null' ? null : assetAddress;
   return {
@@ -113,17 +117,19 @@ export function updateAggregatedBalanceStateForNewAccount(
 ) {
   for (const balanceKey in balanceState) {
     const asset = extractAssetFromBalanceKey(balanceKey as BalanceKey);
-    const assetKey = createAssetKey(asset);
+    if (asset) {
+      const assetKey = createAssetKey(asset);
 
-    if (!aggregatedBalances[assetKey]) {
-      aggregatedBalances[assetKey] = [];
-    }
+      if (!aggregatedBalances[assetKey]) {
+        aggregatedBalances[assetKey] = [];
+      }
 
-    if (!aggregatedBalances[assetKey].includes(balanceKey as BalanceKey)) {
-      aggregatedBalances[assetKey] = [
-        ...aggregatedBalances[assetKey],
-        balanceKey as BalanceKey,
-      ];
+      if (!aggregatedBalances[assetKey].includes(balanceKey as BalanceKey)) {
+        aggregatedBalances[assetKey] = [
+          ...aggregatedBalances[assetKey],
+          balanceKey as BalanceKey,
+        ];
+      }
     }
   }
 
@@ -135,6 +141,9 @@ export function removeBalanceFromAggregatedBalance(
   balanceKey: BalanceKey
 ) {
   const asset = extractAssetFromBalanceKey(balanceKey);
+  if (!asset) {
+    return aggregatedBalances;
+  }
   const assetKey = createAssetKey(asset);
 
   if (aggregatedBalances[assetKey]) {
@@ -205,6 +214,9 @@ export function computeNextStateAfterWalletBalanceRemoval(
 
   balanceKeys.forEach((key) => {
     const asset = extractAssetFromBalanceKey(key);
+    if (!asset) {
+      return;
+    }
 
     const shouldBalanceBeRemoved = !!walletsNeedsToBeRemoved.find(
       (wallet) =>
@@ -221,7 +233,7 @@ export function computeNextStateAfterWalletBalanceRemoval(
         nextAggregatedBalanceState,
         key
       );
-    } else {
+    } else if (currentBalancesState[key]) {
       nextBalancesState[key] = currentBalancesState[key];
     }
   });

package/src/test-utils/fixtures.ts

@@ -240,7 +240,7 @@ export function createInitialAppStore() {
       tokensMapByBlockchainName[token.blockchain] = [];
     }
     tokensMapByTokenHash.set(tokenHash, token);
-    tokensMapByBlockchainName[token.blockchain].push(tokenHash);
+    tokensMapByBlockchainName[token.blockchain]?.push(tokenHash);
   });
 
   return {

package/src/utils/colors.ts

@@ -133,7 +133,10 @@ export function createTintsAndShades(
 
   for (let i = 0; i < length; i++) {
     const index = BASE_INDEX + (isReversed ? length - 1 - i : i) * STEP;
-    colorMap[`${colorKey}${index}`] = combinedColors[i];
+    const color = combinedColors[i];
+    if (color) {
+      colorMap[`${colorKey}${index}`] = color;
+    }
   }
 
   return colorMap;

package/src/utils/configs.ts

@@ -54,15 +54,19 @@ export const isTokenExcludedInConfig = (
   tokensConfig?: TokensConfig
 ) => {
   let result = false;
+
   if (tokensConfig && token) {
     if (Array.isArray(tokensConfig)) {
       result = !tokensConfig.some((asset) => areTokensEqual(asset, token));
-    } else if (!Array.isArray(tokensConfig) && tokensConfig[token.blockchain]) {
-      result = tokensConfig[token.blockchain].tokens.some((asset) =>
-        areTokensEqual(asset, token)
-      );
-      const isExcluded = tokensConfig[token.blockchain].isExcluded;
-      return (!isExcluded && !result) || (isExcluded && result);
+    } else if (!Array.isArray(tokensConfig)) {
+      const configForChain = tokensConfig[token.blockchain];
+      if (configForChain) {
+        result = !!configForChain.tokens.some((asset) =>
+          areTokensEqual(asset, token)
+        );
+        const isExcluded = configForChain.isExcluded;
+        return (!isExcluded && !result) || (isExcluded && result);
+      }
     }
   }
   return result;

package/src/utils/quote.ts

@@ -143,6 +143,16 @@ export function createRetryQuote(
   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,
@@ -336,15 +346,16 @@ export const getDefaultQuote = (
   quotes: MultiRouteSimulationResult[],
   requestAmount: string
 ): SelectedQuote | null => {
-  if (!quotes.length) {
+  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: requestAmount,
+      requestAmount,
       validationStatus: null,
-      ...quotes[0], // Return the first quote from the quotes array
+      ...quote,
     };
   }
   // Create a set of swapperIds from the currentQuote swaps
@@ -365,9 +376,9 @@ export const getDefaultQuote = (
 
   // Return the matchedQuote if found, otherwise return the first quote from the quotes array
   return {
-    requestAmount: requestAmount,
+    requestAmount,
     validationStatus: null,
-    ...(matchedQuote || quotes[0]),
+    ...(matchedQuote || quote),
   };
 };
 

package/src/utils/swap.ts

@@ -109,7 +109,7 @@ export function hasLimitError(swaps: SwapResult[]): boolean {
 }
 
 export function getLimitErrorMessage(swaps: SwapResult[]): {
-  swap: SwapResult;
+  swap?: SwapResult;
   fromAmountRangeError: string;
   recommendation: string;
 } {
@@ -127,6 +127,13 @@ export function getLimitErrorMessage(swaps: SwapResult[]): {
     return minimum?.gt(swap.fromAmount) || maximum?.lt(swap.fromAmount);
   })[0];
 
+  if (!swap) {
+    return {
+      swap: undefined,
+      fromAmountRangeError: '',
+      recommendation: '',
+    };
+  }
   const minimum = !!swap.fromAmountMinValue
     ? new BigNumber(swap.fromAmountMinValue)
     : null;
@@ -279,7 +286,7 @@ export function getUsdFeeOfStep(
   let totalFeeInUsd = ZERO;
   for (let i = 0; i < step.fee.length; i++) {
     const fee = step.fee[i];
-    if (fee.expenseType === 'DECREASE_FROM_OUTPUT') {
+    if (!fee || fee.expenseType === 'DECREASE_FROM_OUTPUT') {
       continue;
     }
 
@@ -557,7 +564,7 @@ export function getWalletsForNewSwap(selectedWallets: Wallet[]) {
 
 export function getUsdInputFrom(quote: SelectedQuote): BigNumber | undefined {
   const inputAmount = quote.requestAmount;
-  const inputTokenUsdPrice = quote.swaps[0].from.usdPrice;
+  const inputTokenUsdPrice = quote.swaps[0]?.from.usdPrice;
   if (!inputAmount || !inputTokenUsdPrice) {
     return;
   }
@@ -566,7 +573,7 @@ export function getUsdInputFrom(quote: SelectedQuote): BigNumber | undefined {
 
 export function getUsdOutputFrom(quote: SelectedQuote): BigNumber | undefined {
   const outputAmount = quote?.outputAmount || null;
-  const outputTokenUsdPrice = quote.swaps[quote.swaps.length - 1].to.usdPrice;
+  const outputTokenUsdPrice = quote.swaps[quote.swaps.length - 1]?.to.usdPrice;
   if (!outputAmount || !outputTokenUsdPrice) {
     return;
   }

package/src/utils/wallets.ts

@@ -296,7 +296,9 @@ export const calculateWalletUsdValue = (balances: BalanceState) => {
 
 function numberWithThousandSeparator(number: string | number): string {
   const parts = number.toString().split('.');
-  parts[0] = formatThousandsWithCommas(parts[0]);
+  if (parts[0]) {
+    parts[0] = formatThousandsWithCommas(parts[0]);
+  }
   return parts.join('.');
 }
 
@@ -311,7 +313,7 @@ export const isExperimentalChain = (
   );
   return (
     cosmosExperimentalChainInfo &&
-    cosmosExperimentalChainInfo[wallet]?.experimental
+    !!cosmosExperimentalChainInfo[wallet]?.experimental
   );
 };