Merge pull request #59 from cosmology-tech/fix/optional-param

Add chainName as optional param to utils

packages/client/README.md

@@ -87,13 +87,13 @@ or get the `ChainInfo` object:
 const chainInfo: ChainInfo = registry.getChainInfo('osmosis');
 
 // AssetList[] of the generated assets
-const assetes: AssetList[] = chainInfo.assetLists;
+const assets: AssetList[] = chainInfo.assetLists;
 
 // Chain 
 const chain: Chain = chainInfo.chain;
 
-// AssetList[] of the native assets
-const assetes: AssetList[] = chainInfo.nativeAssetLists;
+// Native asset list
+const nativeAssetList: AssetList = chainInfo.nativeAssetList;
 ```
 
 ## Related

packages/client/__tests__/client-mock.test.ts

@@ -75,6 +75,6 @@ describe('Test client', () => {
 
  it('Test mock fetching asset list', () => {
  const chainInfo = client.getChainInfo('osmosis');
- expect(chainInfo.nativeAssetLists.assets.length).toEqual(1);
+ expect(chainInfo.nativeAssetList.assets.length).toEqual(1);
  });
 });

packages/client/__tests__/client.api.test.ts

@@ -0,0 +1,86 @@
+import { assets, chains } from 'chain-registry';
+
+import {
+ ChainRegistryChainUtil,
+ ChainRegistryChainUtilOptions,
+ ChainRegistryClient,
+ ChainRegistryClientOptions
+} from '../src';
+
+describe('tests for asset-list-util', () => {
+ const assetLists = assets.filter(
+ ({ chain_name }) => chain_name === 'osmosis'
+ );
+ const chainInfos = chains.filter(
+ ({ chain_name }) => chain_name === 'osmosis'
+ );
+
+ const regOptions: ChainRegistryClientOptions = {
+ chainNames: ['osmosis'],
+ chains: chainInfos,
+ assetLists
+ };
+
+ const regClient = new ChainRegistryClient(regOptions);
+ const chainInfo = regClient.getChainInfo('osmosis');
+ const options: ChainRegistryChainUtilOptions = {
+ chainInfo,
+ chainName: 'osmosis'
+ };
+ const client = new ChainRegistryChainUtil(options);
+
+ it('getAssetByDenom', () => {
+ const asset = client.getAssetByDenom('uosmo');
+ expect(asset.base).toEqual('uosmo');
+ });
+
+ it('getDenomByCoinGeckoId', () => {
+ const denom1 = client.getDenomByCoinGeckoId('osmosis');
+ expect(denom1).toEqual('uosmo');
+ const denom2 = client.getDenomByCoinGeckoId('ion');
+ expect(denom2).toEqual('uion');
+ });
+
+ it('getSymbolByChainDenom', () => {
+ const denom1 = client.getSymbolByChainDenom('uosmo');
+ expect(denom1).toEqual('OSMO');
+ const denom2 = client.getSymbolByChainDenom('uion');
+ expect(denom2).toEqual('ION');
+ });
+
+ it('getChainDenomBySymbol', () => {
+ const denom1 = client.getChainDenomBySymbol('OSMO');
+ expect(denom1).toEqual('uosmo');
+ const denom2 = client.getChainDenomBySymbol('ION');
+ expect(denom2).toEqual('uion');
+ });
+
+ it('getExponentByDenom', () => {
+ const exponent = client.getExponentByDenom('uosmo');
+ expect(exponent).toEqual(6);
+ });
+
+ it('convertBaseUnitsToDollarValue', () => {
+ const value = client.convertBaseUnitsToDollarValue({ uosmo: 1 }, 'OSMO', 5);
+ expect(value).toEqual('0.000005');
+ });
+
+ it('convertDollarValueToDenomUnits', () => {
+ const value = client.convertDollarValueToDenomUnits(
+ { uosmo: 1 },
+ 'OSMO',
+ 0.00001
+ );
+ expect(value).toEqual('10');
+ });
+
+ it('convertBaseUnitsToDisplayUnits', () => {
+ const value = client.convertBaseUnitsToDisplayUnits('OSMO', 99);
+ expect(value).toEqual('0.000099');
+ });
+
+ it('uosmo coingecko id', () => {
+ const id = client.getCoinGeckoIdByDenom('uosmo');
+ expect(id).toEqual('osmosis');
+ });
+});

packages/client/__tests__/fetcher.test.ts

@@ -44,7 +44,7 @@ describe('Test fetcher', () => {
  expect(chainInfo.chain).toEqual(osmosis);
 
  const osmosisAssets = fetcher.getChainAssetList('osmosis');
- expect(chainInfo.nativeAssetLists).toEqual(osmosisAssets);
+ expect(chainInfo.nativeAssetList).toEqual(osmosisAssets);
 
  const num = osmosisAssets.assets.length;
  const numGenerated = generated[0].assets.length;

packages/client/src/chain-info.ts

@@ -43,7 +43,7 @@ export class ChainInfo {
  get chain() {
  return this._chain;
  }
- get nativeAssetLists() {
+ get nativeAssetList() {
  return this._assetList;
  }
  get assetLists() {

packages/client/src/chain-util.ts

@@ -1,4 +1,4 @@
-import { Asset } from '@chain-registry/types';
+import { Asset, AssetList } from '@chain-registry/types';
 import type {
  CoinDenom,
  CoinGeckoUSD,
@@ -12,6 +12,7 @@ import {
  convertDollarValueToDenomUnits,
  getAssetByDenom,
  getChainDenomBySymbol,
+ getCoinGeckoIdByDenom,
  getDenomByCoinGeckoId,
  getExponentByDenom,
  getSymbolByChainDenom,
@@ -28,44 +29,53 @@ export interface ChainRegistryChainUtilOptions {
 export class ChainRegistryChainUtil {
  chainName: string;
  chainInfo: ChainInfo;
- allAsset: Asset[];
+
+ private _assets: AssetList[] = [];
 
  constructor(options: ChainRegistryChainUtilOptions) {
  this.chainName = options.chainName;
  this.chainInfo = options.chainInfo;
- this.allAsset = this.chainInfo.assetLists.reduce(
- (m, it) => {
- [].push.apply(m, it.assets);
- return m;
- },
- [...this.chainInfo.nativeAssetLists.assets]
- );
+ this._assets = [
+ {
+ assets: [
+ ...this.chainInfo.nativeAssetList.assets,
+ ...this.chainInfo.assetLists.flatMap(({ assets }) => assets)
+ ],
+ chain_name: this.chainName
+ }
+ ];
  }
 
  getAssetByDenom(denom: CoinDenom): Asset {
- return getAssetByDenom(this.allAsset, denom);
+ return getAssetByDenom(this._assets, denom, this.chainName);
  }
 
  getDenomByCoinGeckoId(coinGeckoId: string): CoinDenom {
- return getDenomByCoinGeckoId(this.allAsset, coinGeckoId);
+ return getDenomByCoinGeckoId(this._assets, coinGeckoId, this.chainName);
+ }
+
+ getCoinGeckoIdByDenom(coinGeckoId: string): CoinDenom {
+ return getCoinGeckoIdByDenom(this._assets, coinGeckoId, {
+ chainName: this.chainName
+ });
  }
 
  getSymbolByChainDenom(denom: CoinDenom): string {
- return getSymbolByChainDenom(this.allAsset, denom);
+ return getSymbolByChainDenom(this._assets, denom, this.chainName);
  }
 
  getChainDenomBySymbol(token: string): CoinDenom {
- return getChainDenomBySymbol(this.allAsset, token);
+ return getChainDenomBySymbol(this._assets, token, this.chainName);
  }
 
  getExponentByDenom(denom: CoinDenom): Exponent {
- return getExponentByDenom(this.allAsset, denom);
+ return getExponentByDenom(this._assets, denom, this.chainName);
  }
 
  convertCoinGeckoPricesToDenomPriceMap(
  prices: Record<string, CoinGeckoUSD>
  ): PriceHash {
- return convertCoinGeckoPricesToDenomPriceMap(this.allAsset, prices);
+ return convertCoinGeckoPricesToDenomPriceMap(this._assets, prices);
  }
 
  noDecimals(num: number | string): string {
@@ -77,21 +87,38 @@ export class ChainRegistryChainUtil {
  symbol: string,
  amount: string | number
  ): string {
- return convertBaseUnitsToDollarValue(this.allAsset, prices, symbol, amount);
+ return convertBaseUnitsToDollarValue(
+ this._assets,
+ prices,
+ symbol,
+ amount,
+ this.chainName
+ );
  }
 
  convertDollarValueToDenomUnits(
  prices: PriceHash,
  symbol: string,
  value: string | number
  ): string {
- return convertDollarValueToDenomUnits(this.allAsset, prices, symbol, value);
+ return convertDollarValueToDenomUnits(
+ this._assets,
+ prices,
+ symbol,
+ value,
+ this.chainName
+ );
  }
 
  convertBaseUnitsToDisplayUnits(
  symbol: string,
  amount: string | number
  ): string {
- return convertBaseUnitsToDisplayUnits(this.allAsset, symbol, amount);
+ return convertBaseUnitsToDisplayUnits(
+ this._assets,
+ symbol,
+ amount,
+ this.chainName
+ );
  }
 }

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

@@ -7,84 +7,89 @@ import {
  convertDollarValueToDenomUnits,
  getAssetByDenom,
  getChainDenomBySymbol,
- getDenomByCoinGeckoId,
  getCoinGeckoIdByDenom,
+ getDenomByCoinGeckoId,
  getExponentByDenom,
  getSymbolByChainDenom,
  noDecimals
 } 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');
  });
 });