@exodus/assets-feature 9.2.6 → 9.3.1

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [9.3.1](https://github.com/ExodusMovement/exodus/compare/@exodus/assets-feature@9.3.0...@exodus/assets-feature@9.3.1) (2026-08-26)
+
+### Bug Fixes
+
+- **assets:** accumulate changes in load() before single flush ([#44228](https://github.com/ExodusMovement/exodus/issues/44228)) ([401680e](https://github.com/ExodusMovement/exodus/commit/401680ef721d736a349d54e89b044ec54a469b0c))
+
+## [9.3.0](https://github.com/ExodusMovement/exodus/compare/@exodus/assets-feature@9.2.6...@exodus/assets-feature@9.3.0) (2026-08-25)
+
+### Features
+
+- **assets:** add dynamic combined assets generation ([#44197](https://github.com/ExodusMovement/exodus/issues/44197)) ([f107abe](https://github.com/ExodusMovement/exodus/commit/f107abece571af407df3b7154518aa689b8c1a04))
+
 ## [9.2.6](https://github.com/ExodusMovement/exodus/compare/@exodus/assets-feature@9.2.5...@exodus/assets-feature@9.2.6) (2026-07-30)
 
 ### Bug Fixes

package/constants.js

@@ -6,7 +6,12 @@ export const disabledPurposesDefaultConfig = {
   defaults: Object.create(null),
 }
 
+export const assetsModuleDefaultConfig = {
+  useDynamicCombinedAssets: false,
+}
+
 export const defaultConfig = {
   multiAddressMode: multiAddressModeDefaultConfig,
   disabledPurposes: disabledPurposesDefaultConfig,
+  assetsModule: assetsModuleDefaultConfig,
 }

package/index.js

@@ -19,6 +19,7 @@ const assets = (config = Object.create(null)) => {
     compatibilityModeGapLimits,
     compatibilityModeMultiAddressMode,
     searchBasedAssetLoaderPlugin,
+    assetsModule,
   } = { ...defaultConfig, ...config }
 
   return {
@@ -52,6 +53,7 @@ const assets = (config = Object.create(null)) => {
         definition: assetModuleDefinition,
         // storage: { namespace: 'customTokens' },
         aliases: [{ implementationId: 'customTokensStorage', interfaceId: 'storage' }],
+        config: assetsModule,
       },
       { definition: assetPreferencesDefinition },
       { if: { registered: ['customTokensStorage'] }, definition: customTokensMonitorDefinition },

package/module/assets-module.js

@@ -26,6 +26,11 @@ import createFetchival from '@exodus/fetch/create-fetchival'
 import { validateCustomToken } from '@exodus/asset-schema-validation'
 import makeConcurrent from 'make-concurrent'
 import oldToNewStyleTokenNames from '@exodus/asset-legacy-token-name-mapping'
+import {
+  createDynamicCombinedAssetDefinitions,
+  shouldTokenJoinCombinedAsset,
+  findDynamicCombinedAssetForToken,
+} from './dynamic-combined-assets.js'
 
 // oxlint-disable-next-line @exodus/oxlint-plugin-restricted-imports/prefer-basic-utils
 const { get, isEmpty, once, uniq, chunk, pick } = lodash
@@ -79,6 +84,7 @@ export class AssetsModule {
   #fetchival
   #logger
   #invalidTokenNames
+  #useDynamicCombinedAssets
 
   constructor({
     storage,
@@ -118,6 +124,7 @@ export class AssetsModule {
       ),
       ...(config.invalidTokenNames || []),
     ])
+    this.#useDynamicCombinedAssets = config.useDynamicCombinedAssets ?? false
   }
 
   #setRegistry = (registry) => {
@@ -161,11 +168,22 @@ export class AssetsModule {
         console.warn(`Incorrectly referenced supported asset ${name}. Expected ${asset.name}.`)
       })
       .filter(Boolean)
+
+    const combinedAssets = this.#useDynamicCombinedAssets ? [] : this.#combinedAssetsList
+
     this.#setRegistry(
       createAssetRegistry({
-        supportedAssetsList: [...assetsList, ...this.#combinedAssetsList],
+        supportedAssetsList: [...assetsList, ...combinedAssets],
       })
     )
+
+    // Only flush static combined assets - dynamic ones are flushed in load()
+    if (!this.#useDynamicCombinedAssets) {
+      const allCombined = Object.values(this.#registry.getAssets()).filter((a) => a.isCombined)
+      if (allCombined.length > 0) {
+        this.#flushChanges({ added: allCombined })
+      }
+    }
   })
 
   getAssets = () => this.#registry.getAssets()
@@ -186,8 +204,12 @@ export class AssetsModule {
   getBaseAssetNames = () => this.#getAssetNamesBy((asset) => asset.baseAsset.name === asset.name)
 
   load = once(async () => {
+    const allAdded = []
+    const allUpdated = []
+
     try {
       const storedTokens = await this.#readCustomTokens()
+
       const tokens = pickBy(storedTokens, ({ baseAssetName }) => {
         const baseAsset = this.getAsset(baseAssetName)
         return baseAsset?.api?.features?.customTokens
@@ -199,12 +221,48 @@ export class AssetsModule {
       // 3. both of the above from a network that has feature flag customTokens === false
       // It is OK to add all of these to the assets registry
       const { added, updated } = this.#handleFetchedTokens(Object.values(tokens))
-      this.#flushChanges({ added, updated })
+      allAdded.push(...added)
+      allUpdated.push(...updated)
     } catch (e) {
       this.#logger.error('error reading custom tokens from storage: ' + e.message, e)
     }
+
+    if (this.#useDynamicCombinedAssets) {
+      try {
+        const { added, updated } = this.#createDynamicCombinedAssets()
+        allAdded.push(...added)
+        allUpdated.push(...updated)
+      } catch (e) {
+        this.#logger.error('error creating dynamic combined assets: ' + e.message, e)
+      }
+    }
+
+    this.#flushChanges({ added: allAdded, updated: allUpdated })
   })
 
+  #createDynamicCombinedAssets = () => {
+    const allAssets = this.getAssets()
+    const definitions = createDynamicCombinedAssetDefinitions(allAssets)
+
+    const newlyCreatedNames = []
+    for (const definition of definitions) {
+      const existingCombined = this.getAsset(definition.name)
+      if (existingCombined) continue
+
+      this.#registry.addCombinedAsset(definition)
+      newlyCreatedNames.push(definition.name)
+    }
+
+    if (newlyCreatedNames.length > 0) {
+      const newCombinedAssets = newlyCreatedNames.map((name) => this.getAsset(name)).filter(Boolean)
+      const childAssetNames = new Set(newCombinedAssets.flatMap((c) => c.combinedAssetNames))
+      const childAssets = [...childAssetNames].map((name) => this.getAsset(name)).filter(Boolean)
+      return { added: newCombinedAssets, updated: childAssets }
+    }
+
+    return { added: [], updated: [] }
+  }
+
   // Custom tokens API
 
   fetchToken = async (assetId, baseAssetName) => {
@@ -316,16 +374,16 @@ export class AssetsModule {
 
     try {
       const token = await this.fetchToken(assetId, baseAssetName)
-      const { asset, isAdded, updates } = this.#handleFetchedToken(token)
-      const updated = updates.map(this.getAsset)
+      const { asset, isAdded, combinedUpdates, combinedCreated } = this.#handleFetchedToken(token)
+      const updated = combinedUpdates.map(this.getAsset)
+      const added = isAdded ? [asset, ...combinedCreated] : combinedCreated
 
       if (isAdded) {
         await this.#storeCustomTokens([token])
-        this.#flushChanges({ added: [asset], updated })
-      } else {
-        this.#flushChanges({ updated: [asset, ...updated] })
       }
 
+      this.#flushChanges({ added, updated: isAdded ? updated : [asset, ...updated] })
+
       return asset
     } catch (err) {
       this.#logger.warn(`Add custom token ${assetId} error on ${baseAssetName}`, err.message)
@@ -577,6 +635,10 @@ export class AssetsModule {
   }
 
   #handleCombinedParents = ({ name, parents }) => {
+    if (this.#useDynamicCombinedAssets) {
+      return []
+    }
+
     if (!parents) return []
     assert(Array.isArray(parents), 'Array expected')
 
@@ -603,59 +665,121 @@ export class AssetsModule {
     return uniq(updatedCombinedAssetNames)
   }
 
+  #handleDynamicCombinedAssetUpdate = (token) => {
+    if (!this.#useDynamicCombinedAssets) return { updated: [], created: [], members: [] }
+    if (!shouldTokenJoinCombinedAsset(token)) return { updated: [], created: [], members: [] }
+
+    const allAssets = this.getAssets()
+    const combinedAssets = Object.values(allAssets).filter((a) => a.isCombined)
+    const matchingCombined = findDynamicCombinedAssetForToken(token, combinedAssets)
+
+    if (matchingCombined) {
+      if (!matchingCombined.combinedAssetNames.includes(token.name)) {
+        this.#registry.updateCombinedAsset(matchingCombined.name, { addMembers: [token.name] })
+        return { updated: [matchingCombined.name], created: [], members: [] }
+      }
+    } else {
+      const matchingAssets = Object.values(allAssets).filter(
+        (a) =>
+          !a.isCombined &&
+          a.displayTicker?.toLowerCase() === token.displayTicker?.toLowerCase() &&
+          a.displayName?.toLowerCase() === token.displayName?.toLowerCase() &&
+          shouldTokenJoinCombinedAsset(a)
+      )
+
+      if (matchingAssets.length >= 2) {
+        const definitions = createDynamicCombinedAssetDefinitions(matchingAssets)
+        if (definitions.length > 0) {
+          const newCombined = this.#registry.addCombinedAsset(definitions[0])
+          const memberNames = matchingAssets.map((a) => a.name).filter((n) => n !== token.name)
+          return { updated: [], created: [newCombined], members: memberNames }
+        }
+      }
+    }
+
+    return { updated: [], created: [], members: [] }
+  }
+
   #handleFetchedToken = (token) => {
     const asset = this.getAsset(token.name)
-    if (asset) return { asset, isAdded: false, updates: [] }
+    if (asset) {
+      const dynamicResult = this.#handleDynamicCombinedAssetUpdate(asset)
+      return {
+        asset,
+        isAdded: false,
+        combinedUpdates: dynamicResult.updated,
+        combinedCreated: dynamicResult.created,
+        combinedMembers: dynamicResult.members,
+      }
+    }
 
-    const { name } = this.#registry.addCustomToken(token) // add to registry
-    const updates = this.#handleCombinedParents(token)
+    const { name } = this.#registry.addCustomToken(token)
+    const staticUpdates = this.#handleCombinedParents(token)
+    const dynamicResult = this.#handleDynamicCombinedAssetUpdate(this.getAsset(name))
+    const combinedUpdates = [...staticUpdates, ...dynamicResult.updated]
 
     this.#logger.log('Custom token added:', name)
-    return { asset: this.getAsset(name), isAdded: true, updates }
+    return {
+      asset: this.getAsset(name),
+      isAdded: true,
+      combinedUpdates,
+      combinedCreated: dynamicResult.created,
+      combinedMembers: dynamicResult.members,
+    }
   }
 
   #handleFetchedTokens = (tokens) => {
     const fetchedAndHandledTokens = []
     const added = []
     const updated = []
-    const parentNames = []
+    const combinedUpdateNames = []
+    const combinedCreated = []
+    const combinedMemberNames = []
+
     for (const token of tokens) {
       try {
-        const { asset, isAdded, updates } = this.#handleFetchedToken(token)
+        const result = this.#handleFetchedToken(token)
 
-        if (isAdded) {
-          added.push(asset)
+        if (result.isAdded) {
+          added.push(result.asset)
           fetchedAndHandledTokens.push(token)
         } else {
-          updated.push(asset)
+          updated.push(result.asset)
+        }
+
+        if (result.combinedUpdates.length > 0) {
+          combinedUpdateNames.push(...result.combinedUpdates)
         }
 
-        if (updates.length > 0) {
-          parentNames.push(...updates)
+        if (result.combinedCreated.length > 0) {
+          combinedCreated.push(...result.combinedCreated)
+        }
+
+        if (result.combinedMembers.length > 0) {
+          combinedMemberNames.push(...result.combinedMembers)
         }
       } catch (err) {
         this.#logger.error('Handle fetched custom tokens error: ' + err.message, err)
       }
     }
 
-    updated.push(...uniq(parentNames).map(this.getAsset))
+    const createdNames = new Set(combinedCreated.map((a) => a.name))
+    const dedupedUpdateNames = uniq(combinedUpdateNames).filter((name) => !createdNames.has(name))
+    const dedupedMemberNames = uniq(combinedMemberNames).filter((name) => !createdNames.has(name))
+    updated.push(...dedupedUpdateNames.map(this.getAsset).filter(Boolean))
+    updated.push(...dedupedMemberNames.map(this.getAsset).filter(Boolean))
+    added.push(...combinedCreated.map((a) => this.getAsset(a.name)).filter(Boolean))
 
     return { fetchedAndHandledTokens, added, updated }
   }
 
-  #fetchIcon = memoizeLruCache(
+  #fetchIconToken = memoizeLruCache(
     async (assetName) => {
-      const tokenNames = [assetName]
-
-      const tokens = await this.#fetch(
-        'tokens',
-        { tokenNames, lifecycleStatus: ['c', 'v', 'u'] },
-        'tokens'
-      )
-      const token = tokens[0]
-      if (token?.icon) {
-        return this.#iconsStorage.unzipIcon(token.icon)
-      }
+      const tokens = await this.#fetchTokensByNames({
+        tokenNames: [assetName],
+        allowedStatusList: ['c', 'v', 'u'],
+      })
+      return tokens[0]
     },
     (assetName) => assetName,
     { max: 100 }
@@ -666,11 +790,21 @@ export class AssetsModule {
 
     const asset = await this.getAsset(assetName)
     if (asset) {
-      return this.#iconsStorage.getIcon(assetName)
+      try {
+        const storedIcon = await this.#iconsStorage.getIcon(assetName)
+        if (storedIcon) return storedIcon
+      } catch (e) {
+        this.#logger.warn(`Failed to read stored icon for ${assetName}. ${e.message}`, e)
+      }
+
+      if (asset.isBuiltIn) return
     }
 
     try {
-      return await this.#fetchIcon(assetName)
+      const token = await this.#fetchIconToken(assetName)
+      if (!token?.icon) return
+      if (asset) await this.#storeIcons([token])
+      return this.#iconsStorage.unzipIcon(token.icon)
     } catch (e) {
       this.#logger.error(`Cannot load icon for ${assetName} from CTR. ${e.message}`, e)
     }

package/module/dynamic-combined-assets.js

@@ -0,0 +1,106 @@
+const TRUSTED_LIFECYCLE = new Set(['c'])
+const MIN_ASSETS_TO_COMBINE = 2
+
+const normalizeForKey = (str) => str.toLowerCase().trim()
+
+const normalizeForName = (str) => str.toLowerCase().replace(/[^a-z0-9]/g, '')
+
+const createGroupKey = (displayTicker, displayName) =>
+  `${normalizeForKey(displayTicker)}::${normalizeForKey(displayName)}`
+
+const groupAssetsByTickerAndName = (assets) => {
+  const groups = Object.create(null)
+
+  for (const asset of assets) {
+    if (asset.isCombined || !asset.displayTicker || !asset.displayName) continue
+
+    const key = createGroupKey(asset.displayTicker, asset.displayName)
+    if (!groups[key]) groups[key] = []
+    groups[key].push(asset)
+  }
+
+  return groups
+}
+
+const selectPrimaryAsset = (assets) => {
+  const sorted = [...assets].sort((a, b) => a.name.localeCompare(b.name))
+  return sorted[0]
+}
+
+const resolveDecimals = (assets) => {
+  const decimals = assets.map((a) => a.currency?.defaultUnit?.power ?? 8)
+  return Math.max(...decimals)
+}
+
+const createDynamicCombinedAssetDefinition = (assetGroup) => {
+  const primary = selectPrimaryAsset(assetGroup)
+  const sortedAssets = [...assetGroup].sort((a, b) => a.name.localeCompare(b.name))
+
+  const normalizedTicker = normalizeForName(primary.displayTicker)
+  const normalizedDisplayName = normalizeForName(primary.displayName)
+  const decimals = resolveDecimals(assetGroup)
+
+  const name = `_combined_${normalizedTicker}_${normalizedDisplayName}`
+  const ticker = name.toUpperCase()
+
+  return {
+    name,
+    ticker,
+    baseAssetName: name,
+    displayName: primary.displayName,
+    displayTicker: primary.displayTicker,
+    assetType: 'MULTI_NETWORK_ASSET',
+    units: {
+      [`${name}_base`]: 0,
+      [ticker]: decimals,
+    },
+    combinedAssetNames: sortedAssets.map((a) => a.name),
+    info: primary.info || { description: '' },
+    primaryColor: primary.primaryColor || '#888888',
+    gradientColors: primary.gradientColors || ['#888888', '#666666'],
+    chainBadgeColors: primary.chainBadgeColors || primary.gradientColors || ['#888888', '#666666'],
+  }
+}
+
+export const isTrustedAsset = (asset) => {
+  // Built-in assets (bundled with app, not fetched from CTR) are trusted
+  if (asset.isBuiltIn === true && asset.isCustomToken !== true) return true
+
+  // Curated custom tokens from CTR are trusted (Exodus controls curation)
+  if (TRUSTED_LIFECYCLE.has(asset.lifecycleStatus)) return true
+
+  return false
+}
+
+export const createDynamicCombinedAssetDefinitions = (assets) => {
+  const assetList = Array.isArray(assets) ? assets : Object.values(assets)
+  const trustedAssets = assetList.filter(isTrustedAsset)
+  const groups = groupAssetsByTickerAndName(trustedAssets)
+
+  const definitions = []
+  for (const assetGroup of Object.values(groups)) {
+    if (assetGroup.length >= MIN_ASSETS_TO_COMBINE) {
+      definitions.push(createDynamicCombinedAssetDefinition(assetGroup))
+    }
+  }
+
+  return definitions
+}
+
+export const findDynamicCombinedAssetForToken = (token, existingCombinedAssets) => {
+  if (!token.displayTicker || !token.displayName) return null
+
+  const tokenKey = createGroupKey(token.displayTicker, token.displayName)
+
+  for (const combined of existingCombinedAssets) {
+    if (!combined.isCombined) continue
+    if (!combined.displayTicker || !combined.displayName) continue
+
+    const combinedKey = createGroupKey(combined.displayTicker, combined.displayName)
+    if (combinedKey === tokenKey) return combined
+  }
+
+  return null
+}
+
+export const shouldTokenJoinCombinedAsset = (token) => isTrustedAsset(token)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/assets-feature",
-  "version": "9.2.6",
+  "version": "9.3.1",
   "license": "MIT",
   "description": "This Exodus SDK feature provides access to instances of all blockchain asset adapters supported by the wallet, and enables you to search for and add custom tokens at runtime.",
   "type": "module",
@@ -40,11 +40,11 @@
     "@exodus/asset-schema-validation": "^1.2.0",
     "@exodus/asset-types": "^0.5.0",
     "@exodus/assets": "^11.3.0",
-    "@exodus/atoms": "^10.3.3",
-    "@exodus/basic-utils": "^5.0.0",
+    "@exodus/atoms": "^10.3.4",
+    "@exodus/basic-utils": "^5.2.0",
     "@exodus/fetch": "^1.3.0",
     "@exodus/fusion-atoms": "^1.4.0",
-    "@exodus/timer": "^1.1.2",
+    "@exodus/timer": "^1.2.2",
     "lodash": "^4.17.21",
     "make-concurrent": "^5.4.0",
     "minimalistic-assert": "^1.0.1",
@@ -52,17 +52,16 @@
     "reselect": "^3.0.1"
   },
   "devDependencies": {
-    "@exodus/available-assets": "^8.11.0",
+    "@exodus/available-assets": "^8.11.1",
     "@exodus/bip32": "^4.3.0",
     "@exodus/bip39": "^1.1.0",
-    "@exodus/bip44-constants": "^195.0.0",
+    "@exodus/bip44-constants": "^195.0.2",
     "@exodus/bitcoin-meta": "^2.0.0",
     "@exodus/bitcoin-plugin": "^2.0.0",
     "@exodus/bitcoinregtest-plugin": "^2.0.0",
     "@exodus/bitcointestnet-plugin": "^2.0.0",
     "@exodus/blockchain-metadata": "^17.2.0",
     "@exodus/cardano-lib": "^4.0.0",
-    "@exodus/combined-assets-meta": "^3.7.0",
     "@exodus/cosmos-plugin": "^1.3.3",
     "@exodus/ethereum-lib": "^5.0.0",
     "@exodus/ethereum-meta": "^2.0.0",
@@ -75,8 +74,8 @@
     "@exodus/public-key-provider": "^4.3.1",
     "@exodus/redux-dependency-injection": "^5.0.0",
     "@exodus/storage-memory": "^2.4.0",
-    "@exodus/wallet-accounts": "^20.4.10",
-    "@exodus/wild-emitter": "^1.0.0",
+    "@exodus/wallet-accounts": "^20.4.11",
+    "@exodus/wild-emitter": "^1.1.2",
     "events": "^3.3.0",
     "msw": "^2.0.0",
     "redux": "^4.0.0"
@@ -85,5 +84,5 @@
     "access": "public",
     "provenance": false
   },
-  "gitHead": "07897763e7cbfa9cf251bd7c436537e059c9fbab"
+  "gitHead": "69a95445c733ef5519ac3fde6632fa9afc399b76"
 }