feat: add chainName as optional param

packages/utils/__tests__/asset-list-util.test.js

@@ -15,76 +15,81 @@ import {
 } from '../src';
 
 describe('tests for asset-list-util', () => {
-  let testAssets = [];
-
-  beforeAll(() => {
-    testAssets = assets.find((it) => it.chain_name === 'osmosis')?.assets || [];
-  });
-
-  it('get osmosis asset by denom', () => {
-    const asset = getAssetByDenom(testAssets, 'uosmo');
-    expect(asset.name).toEqual('Osmosis');
+  const osmosisAssetList = assets.filter(
+    ({ chain_name }) => chain_name === 'osmosis'
+  );
+
+  it('getAssetByDenom', () => {
+    expect(() => getAssetByDenom(assets, 'uosmo')).toThrowError();
+    const asset = getAssetByDenom(assets, 'uosmo', 'osmosis');
+    expect(asset.base).toEqual('uosmo');
   });
 
-  it('get osmosis denom by geckoId', () => {
-    const denom = getDenomByCoinGeckoId(testAssets, 'osmosis');
-    expect(denom).toEqual('uosmo');
+  it('getDenomByCoinGeckoId', () => {
+    const denom1 = getDenomByCoinGeckoId(assets, 'jackal');
+    expect(denom1).toEqual('ujkl');
+    const denom2 = getDenomByCoinGeckoId(assets, 'stargaze', 'stargaze');
+    expect(denom2).toEqual('ustars');
   });
 
-  it('get osmosis symbol by denom', () => {
-    const token = getSymbolByChainDenom(testAssets, 'uosmo');
-    expect(token).toEqual('OSMO');
+  it('getSymbolByChainDenom', () => {
+    const denom1 = getSymbolByChainDenom(assets, 'swth');
+    expect(denom1).toEqual('SWTH');
+    const denom2 = getSymbolByChainDenom(assets, 'uusdc', 'axelar');
+    expect(denom2).toEqual('USDC');
   });
 
-  it('get osmosis denom by symbol', () => {
-    const denom = getChainDenomBySymbol(testAssets, 'OSMO');
-    expect(denom).toEqual('uosmo');
+  it('getChainDenomBySymbol', () => {
+    const denom1 = getChainDenomBySymbol(assets, 'OCTA');
+    expect(denom1).toEqual('uocta');
+    const denom2 = getChainDenomBySymbol(assets, 'NOM', 'nomic');
+    expect(denom2).toEqual('unom');
   });
 
-  it('get osmosis exponent by denom', () => {
-    const exponent = getExponentByDenom(testAssets, 'uosmo');
+  it('getExponentByDenom', () => {
+    const exponent = getExponentByDenom(assets, 'uosmo', 'osmosis');
     expect(exponent).toEqual(6);
   });
 
-  it('convert osmosis gecko price to denom price map', () => {
-    const priceMap = convertCoinGeckoPricesToDenomPriceMap(testAssets, {
+  it('convertCoinGeckoPricesToDenomPriceMap', () => {
+    const priceMap = convertCoinGeckoPricesToDenomPriceMap(osmosisAssetList, {
       osmosis: {
         usd: 0.498124
       }
     });
     expect(priceMap.uosmo).toEqual(0.498124);
   });
 
-  it('convert number no decimals', () => {
+  it('noDecimals', () => {
     const re1 = noDecimals(1.12);
     expect(re1).toEqual('1');
     const re2 = noDecimals(1.67);
     expect(re2).toEqual('1');
   });
 
-  it('convert osmosis base units to dollar value', () => {
-    const re = convertBaseUnitsToDollarValue(
-      testAssets,
+  it('convertBaseUnitsToDollarValue', () => {
+    const value = convertBaseUnitsToDollarValue(
+      osmosisAssetList,
       { uosmo: 1 },
       'OSMO',
       5
     );
-    expect(re).toEqual('0.000005');
+    expect(value).toEqual('0.000005');
   });
 
-  it('convert doller value to osmosis denom units', () => {
-    const re = convertDollarValueToDenomUnits(
-      testAssets,
+  it('convertDollarValueToDenomUnits', () => {
+    const value = convertDollarValueToDenomUnits(
+      osmosisAssetList,
       { uosmo: 1 },
       'OSMO',
       0.00001
     );
-    expect(re).toEqual('10');
+    expect(value).toEqual('10');
   });
 
-  it('convert osmosis base units to display units', () => {
-    const re = convertBaseUnitsToDisplayUnits(testAssets, 'OSMO', 99);
-    expect(re).toEqual('0.000099');
+  it('convertBaseUnitsToDisplayUnits', () => {
+    const value = convertBaseUnitsToDisplayUnits(osmosisAssetList, 'OSMO', 99);
+    expect(value).toEqual('0.000099');
   });
 });
 

packages/utils/src/asset-list-util.ts

@@ -13,19 +13,46 @@ export interface PriceHash {
   [key: CoinDenom]: number;
 }
 
-export function getAssetByDenom(assets: Asset[], denom: CoinDenom): Asset {
-  const asset = assets.find((asset) => asset.base === denom);
-  if (!asset) {
-    throw new Error(`Asset not found: ${denom}`);
+function getAssetByKeyValue(
+  assets: AssetList[],
+  key: keyof Asset,
+  value: string,
+  chainName?: string
+): Asset {
+  const filteredAssets = assets
+    .filter(({ chain_name }) => !chainName || chain_name === chainName)
+    .flatMap(({ assets }) => assets);
+
+  const matchingAssets = filteredAssets.filter((asset) => asset[key] === value);
+
+  if (matchingAssets.length === 0) {
+    throw new Error(`No asset found for ${key} '${value}'`);
+  }
+
+  if (matchingAssets.length > 1) {
+    throw new Error(
+      `Ambiguity: ${matchingAssets.length} assets found for ${key} '${value}'`
+    );
   }
-  return asset;
+
+  return matchingAssets[0];
+}
+
+export function getAssetByDenom(
+  assets: AssetList[],
+  denom: CoinDenom,
+  chainName?: string
+): Asset {
+  return getAssetByKeyValue(assets, 'base', denom, chainName);
 }
 
 export function getDenomByCoinGeckoId(
-  assets: Asset[],
-  coinGeckoId: string
+  assets: AssetList[],
+  coinGeckoId: string,
+  chainName?: string
 ): CoinDenom {
-  return assets.find((asset) => asset.coingecko_id === coinGeckoId).base;
+  return getAssetByKeyValue(assets, 'coingecko_id', coinGeckoId, chainName)
+    .base;
 }
 
 type GetCoinGeckoIdByDenomOptions = {
@@ -61,44 +88,36 @@ export function getCoinGeckoIdByDenom(
 }
 
 export function getSymbolByChainDenom(
-  assets: Asset[],
-  denom: CoinDenom
+  assets: AssetList[],
+  denom: CoinDenom,
+  chainName?: string
 ): string {
-  const asset = getAssetByDenom(assets, denom);
-  const symbol = asset.symbol;
-  if (!symbol) {
-    return denom;
-  }
-  return symbol;
+  return getAssetByDenom(assets, denom, chainName).symbol;
 }
 
 export function getChainDenomBySymbol(
-  assets: Asset[],
-  token: string
+  assets: AssetList[],
+  symbol: string,
+  chainName?: string
 ): CoinDenom {
-  const asset = assets.find(({ symbol }) => symbol === token);
-  const base = asset?.base;
-  if (!base) {
-    console.log(`cannot find base for token ${token}`);
-    return null;
-  }
-  return base;
+  return getAssetByKeyValue(assets, 'symbol', symbol, chainName).base;
 }
 
 export function getExponentByDenom(
-  assets: Asset[],
-  denom: CoinDenom
+  assets: AssetList[],
+  denom: CoinDenom,
+  chainName?: string
 ): Exponent {
-  const asset = getAssetByDenom(assets, denom);
+  const asset = getAssetByDenom(assets, denom, chainName);
   const unit = asset.denom_units.find(({ denom }) => denom === asset.display);
-  return unit?.exponent || 0;
+  return unit?.exponent ?? 0;
 }
 
 export function convertCoinGeckoPricesToDenomPriceMap(
-  assets: Asset[],
+  assets: AssetList[],
   prices: Record<string, CoinGeckoUSD>
 ): PriceHash {
-  return Object.keys(prices).reduce((res, geckoId) => {
+  return Object.keys(prices).reduce((res: PriceHash, geckoId) => {
     const denom = getDenomByCoinGeckoId(assets, geckoId);
     res[denom] = prices[geckoId].usd;
     return res;
@@ -110,7 +129,7 @@ export function noDecimals(num: number | string): string {
 }
 
 export function convertBaseUnitsToDollarValue(
-  assets: Asset[],
+  assets: AssetList[],
   prices: PriceHash,
   symbol: string,
   amount: string | number
@@ -123,7 +142,7 @@ export function convertBaseUnitsToDollarValue(
 }
 
 export function convertDollarValueToDenomUnits(
-  assets: Asset[],
+  assets: AssetList[],
   prices: PriceHash,
   symbol: string,
   value: string | number
@@ -136,7 +155,7 @@ export function convertDollarValueToDenomUnits(
 }
 
 export function convertBaseUnitsToDisplayUnits(
-  assets: Asset[],
+  assets: AssetList[],
   symbol: string,
   amount: string | number
 ): string {