feat(statics): add method to insert single token in coin map

Ticket: WIN-5359

Author: veetragjain

modules/statics/src/coins.ts

@@ -3154,11 +3154,29 @@ export const coins = CoinMap.fromCoins([
   ),
 ]);
 
-function createToken(
-  family: string,
-  token: AmsTokenConfig,
-  initializerMap: Record<string, unknown>
-): Readonly<BaseCoin> | undefined {
+export function createToken(token: AmsTokenConfig): Readonly<BaseCoin> | undefined {
+  const initializerMap: Record<string, unknown> = {
+    algo: algoToken,
+    apt: aptToken,
+    arbeth: arbethErc20,
+    avaxc: avaxErc20,
+    bera: beraErc20,
+    bsc: bscToken,
+    celo: celoToken,
+    eth: erc20,
+    eos: eosToken,
+    hbar: hederaToken,
+    opeth: opethErc20,
+    polygon: polygonErc20,
+    sol: solToken,
+    stx: sip10Token,
+    sui: suiToken,
+    trx: tronToken,
+    xlm: stellarToken,
+    xrp: xrpToken,
+  };
+
+  const family = token.family;
   const initializer = initializerMap[family] as (...args: unknown[]) => Readonly<BaseCoin>;
   if (!initializer) {
     return undefined;
@@ -3290,47 +3308,12 @@ function getAptTokenInitializer(token: AmsTokenConfig) {
   };
 }
 
-export function isCoinPresentInCoinMap({
-  name,
-  id,
-  contractAddress,
-  alias,
-}: {
-  name: string;
-  id?: string;
-  contractAddress?: string;
-  alias?: string;
-}): boolean {
-  return Boolean(
-    coins.has(name) ||
-      (id && coins.has(id)) ||
-      (contractAddress && coins.has(contractAddress)) ||
-      (alias && coins.has(alias))
-  );
+export function isCoinPresentInCoinMap({ name, id, alias }: { name: string; id?: string; alias?: string }): boolean {
+  return Boolean(coins.has(name) || (id && coins.has(id)) || (alias && coins.has(alias)));
 }
 
 export function createTokenMapUsingConfigDetails(tokenConfigMap: Record<string, AmsTokenConfig[]>): CoinMap {
   const BaseCoins: Map<string, Readonly<BaseCoin>> = new Map();
-  const initializerMap: Record<string, unknown> = {
-    algo: algoToken,
-    apt: aptToken,
-    arbeth: arbethErc20,
-    avaxc: avaxErc20,
-    bera: beraErc20,
-    bsc: bscToken,
-    celo: celoToken,
-    eth: erc20,
-    eos: eosToken,
-    hbar: hederaToken,
-    opeth: opethErc20,
-    polygon: polygonErc20,
-    sol: solToken,
-    stx: sip10Token,
-    sui: suiToken,
-    trx: tronToken,
-    xlm: stellarToken,
-    xrp: xrpToken,
-  };
 
   const nftAndOtherTokens = new Set([
     'erc721:bsctoken',
@@ -3360,14 +3343,13 @@ export function createTokenMapUsingConfigDetails(tokenConfigMap: Record<string,
   // add the tokens not present in the static coin map
   for (const tokenConfigs of Object.values(tokenConfigMap)) {
     const tokenConfig = tokenConfigs[0];
-    const family = tokenConfig.family;
 
     if (
       !isCoinPresentInCoinMap({ ...tokenConfig }) &&
       tokenConfig.isToken &&
       !nftAndOtherTokens.has(tokenConfig.name)
     ) {
-      const token = createToken(family, tokenConfig, initializerMap);
+      const token = createToken(tokenConfig);
       if (token) {
         BaseCoins.set(token.name, token);
       }

modules/statics/src/map.ts

@@ -18,33 +18,37 @@ export class CoinMap {
   }
 
   static fromCoins(coins: Readonly<BaseCoin>[]): CoinMap {
-    return coins.reduce((coinMap, coin) => {
-      if (coinMap.has(coin.name)) {
-        throw new DuplicateCoinDefinitionError(coin.name);
-      }
-      coinMap._map.set(coin.name, coin);
+    const coinMap = new CoinMap();
+    coins.forEach((coin) => {
+      coinMap.addCoin(coin);
+    });
+    return coinMap;
+  }
 
-      if (coinMap._coinByIds.has(coin.id)) {
-        throw new DuplicateCoinIdDefinitionError(coin.id);
-      }
-      coinMap._coinByIds.set(coin.id, coin);
+  public addCoin(coin: Readonly<BaseCoin>): void {
+    if (this._map.has(coin.name)) {
+      throw new DuplicateCoinDefinitionError(coin.name);
+    }
+    if (this._coinByIds.has(coin.id)) {
+      throw new DuplicateCoinIdDefinitionError(coin.id);
+    }
+    const alias = coin.alias;
+    if (alias && this._coinByAliases.has(alias)) {
+      throw new DuplicateCoinDefinitionError(alias);
+    }
+    this._map.set(coin.name, coin);
+    this._coinByIds.set(coin.id, coin);
+    if (alias) {
+      this._coinByAliases.set(coin.alias, coin);
+    }
 
-      const alias = coin.alias;
-      if (alias) {
-        if (coinMap.has(alias)) {
-          throw new DuplicateCoinDefinitionError(alias);
-        }
-        coinMap._coinByAliases.set(alias, coin);
+    if (coin.isToken) {
+      if (coin instanceof ContractAddressDefinedToken) {
+        this._coinByContractAddress.set(`${coin.family}:${coin.contractAddress}`, coin);
+      } else if (coin instanceof NFTCollectionIdDefinedToken) {
+        this._coinByNftCollectionID.set(`${coin.prefix}${coin.family}:${coin.nftCollectionId}`, coin);
       }
-      if (coin.isToken) {
-        if (coin instanceof ContractAddressDefinedToken) {
-          coinMap._coinByContractAddress.set(`${coin.family}:${coin.contractAddress}`, coin);
-        } else if (coin instanceof NFTCollectionIdDefinedToken) {
-          coinMap._coinByNftCollectionID.set(`${coin.prefix}${coin.family}:${coin.nftCollectionId}`, coin);
-        }
-      }
-      return coinMap;
-    }, new CoinMap());
+    }
   }
 
   static coinNameFromChainId(chainId: number): string {

modules/statics/test/unit/coins.ts

@@ -21,6 +21,7 @@ import {
   getFormattedTokens,
   createTokenMapUsingConfigDetails,
   createTokenMapUsingTrimmedConfigDetails,
+  createToken,
 } from '../../src';
 import { utxo } from '../../src/utxo';
 import { expectedColdFeatures } from './fixtures/expectedColdFeatures';
@@ -649,6 +650,16 @@ describe('CoinMap', function () {
     const nftCollectionStatics = coins.get('tapt:0xbbc561fbfa5d105efd8dfb06ae3e7e5be46331165b99d518f094c701e40603b5');
     nftCollectionStatics.name.should.eql('tapt:nftcollection1');
   });
+
+  it('should add single coin/token into the coin map', () => {
+    const coinMap = CoinMap.fromCoins([]);
+    const coin = coins.get('btc');
+    const token = coins.get('usdc');
+    coinMap.addCoin(coin);
+    coinMap.has(coin.name).should.be.true();
+    coinMap.addCoin(token);
+    coinMap.has(token.name).should.be.true();
+  });
 });
 
 coins.forEach((coin, coinName) => {
@@ -979,4 +990,12 @@ describe('create token map using config details', () => {
     tokenRest1.should.deepEqual(tokenRest2);
     JSON.stringify(tokenNetwork1).should.eql(JSON.stringify(tokenNetwork2));
   });
+  it('should be able to add single ams token into coin map', () => {
+    const coinMap = CoinMap.fromCoins([]);
+    const staticsCoin = createToken(amsTokenConfigWithCustomToken['hteth:faketoken'][0]);
+    if (staticsCoin) {
+      coinMap.addCoin(staticsCoin);
+    }
+    coinMap.has('hteth:faketoken').should.be.true();
+  });
 });