@subwallet/extension-base 1.1.21-3 → 1.1.23-0

package/services/history-service/index.js

@@ -2,24 +2,32 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ExtrinsicStatus } from '@subwallet/extension-base/background/KoniTypes';
-import { CRON_RECOVER_HISTORY_INTERVAL, CRON_REFRESH_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
+import { CRON_RECOVER_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { historyRecover, HistoryRecoverStatus } from '@subwallet/extension-base/services/history-service/helpers/recoverHistoryStatus';
+import { getExtrinsicParserKey } from '@subwallet/extension-base/services/history-service/helpers/subscan-extrinsic-parser-helper';
+import { parseSubscanExtrinsicData, parseSubscanTransferData } from '@subwallet/extension-base/services/history-service/subscan-history';
+import { reformatAddress } from '@subwallet/extension-base/utils';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { keyring } from '@subwallet/ui-keyring';
 import { BehaviorSubject } from 'rxjs';
+function filterHistoryItemByAddressAndChain(chain, address) {
+  return item => {
+    return item.chain === chain && item.address === address;
+  };
+}
 export class HistoryService {
   historySubject = new BehaviorSubject([]);
   #needRecoveryHistories = {};
-  constructor(dbService, chainService, eventService, keyringService) {
+  constructor(dbService, chainService, eventService, keyringService, subscanService) {
     this.dbService = dbService;
     this.chainService = chainService;
     this.eventService = eventService;
     this.keyringService = keyringService;
+    this.subscanService = subscanService;
     this.init().catch(console.error);
   }
   fetchPromise = null;
-  interval = undefined;
   recoverInterval = undefined;
   async fetchAndLoadHistories(addresses) {
     if (!addresses || addresses.length === 0) {
@@ -60,6 +68,74 @@ export class HistoryService {
     await this.getHistories();
     return this.historySubject;
   }
+  fetchSubscanTransactionHistory(chain, address) {
+    if (!this.subscanService.checkSupportedSubscanChain(chain)) {
+      return;
+    }
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const excludeExtrinsicParserKeys = ['balances.transfer_all'];
+
+    // Note: fetchAllPossibleExtrinsicItems and fetchAllPossibleTransferItems-receive can run parallelly
+    // Hover, fetchAllPossibleTransferItems-sent must run after fetchAllPossibleExtrinsicItems,
+    // to avoid "duplicate Extrinsic Hash between items" problem
+
+    this.subscanService.fetchAllPossibleExtrinsicItems(chain, address, extrinsicItems => {
+      const result = [];
+      extrinsicItems.forEach(x => {
+        const item = parseSubscanExtrinsicData(address, x, chainInfo);
+        if (item) {
+          result.push(item);
+        }
+      });
+      this.addHistoryItems(result).catch(e => {
+        console.log('addHistoryItems in fetchAllPossibleExtrinsicItems error', e);
+      });
+    }).then(extrinsicItems => {
+      const excludeTransferExtrinsicHash = [];
+      extrinsicItems.forEach(x => {
+        if (!excludeExtrinsicParserKeys.includes(getExtrinsicParserKey(x))) {
+          excludeTransferExtrinsicHash.push(x.extrinsic_hash);
+        }
+      });
+      this.subscanService.fetchAllPossibleTransferItems(chain, address, 'sent', transferItems => {
+        const result = [];
+        transferItems.forEach(t => {
+          if (!excludeTransferExtrinsicHash.includes(t.hash)) {
+            result.push(parseSubscanTransferData(address, t, chainInfo));
+          }
+        });
+        this.addHistoryItems(result).catch(e => {
+          console.log('addHistoryItems in fetchAllPossibleTransferItems-sent error', e);
+        });
+      }).catch(e => {
+        console.log('fetchAllPossibleTransferItems-sent error', e);
+      });
+    }).catch(e => {
+      console.log('fetchAllPossibleExtrinsicItems error', e);
+    });
+    this.subscanService.fetchAllPossibleTransferItems(chain, address, 'received', transferItems => {
+      const result = [];
+      transferItems.forEach(t => {
+        result.push(parseSubscanTransferData(address, t, chainInfo));
+      });
+      this.addHistoryItems(result).catch(e => {
+        console.log('addHistoryItems in fetchAllPossibleTransferItems-receive error', e);
+      });
+    }).catch(e => {
+      console.log('fetchAllPossibleTransferItems-receive error', e);
+    });
+  }
+  subscribeHistories(chain, address, cb) {
+    const _address = reformatAddress(address);
+    const subscription = this.historySubject.subscribe(items => {
+      cb(items.filter(filterHistoryItemByAddressAndChain(chain, _address)));
+    });
+    this.fetchSubscanTransactionHistory(chain, _address);
+    return {
+      unsubscribe: subscription.unsubscribe,
+      value: this.historySubject.getValue().filter(filterHistoryItemByAddressAndChain(chain, _address))
+    };
+  }
   async updateHistories(chain, extrinsicHash, updateData) {
     const existedRecords = await this.dbService.getHistories({
       chain,
@@ -110,17 +186,6 @@ export class HistoryService {
   async persistData() {
     await this.dbService.upsertHistory(this.historySubject.value);
   }
-  async startCron() {
-    await this.getHistories();
-    this.interval = setInterval(() => {
-      this.getHistories().catch(console.error);
-    }, CRON_REFRESH_HISTORY_INTERVAL);
-  }
-  stopCron() {
-    clearTimeout(this.interval);
-    this.fetchPromise = null;
-    return Promise.resolve();
-  }
   async startRecoverHistories() {
     await this.recoverHistories();
     this.recoverInterval = setInterval(() => {
@@ -175,12 +240,6 @@ export class HistoryService {
     Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
       this.getHistories().catch(console.log);
       this.recoverProcessingHistory().catch(console.error);
-      this.eventService.on('account.add', () => {
-        (async () => {
-          await this.stopCron();
-          await this.startCron();
-        })().catch(console.error);
-      });
       this.eventService.on('account.remove', address => {
         this.removeHistoryByAddress(address).catch(console.error);
       });
@@ -209,7 +268,6 @@ export class HistoryService {
       await Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]);
       this.startPromiseHandler = createPromiseHandler();
       this.status = ServiceStatus.STARTING;
-      await this.startCron();
       this.status = ServiceStatus.STARTED;
       this.startPromiseHandler.resolve();
     } catch (e) {
@@ -225,7 +283,6 @@ export class HistoryService {
       this.stopPromiseHandler = createPromiseHandler();
       this.status = ServiceStatus.STOPPING;
       await this.persistData();
-      await this.stopCron();
       await this.stopRecoverHistories();
       this.stopPromiseHandler.resolve();
       this.status = ServiceStatus.STOPPED;

package/services/history-service/subscan-history.d.ts

@@ -0,0 +1,5 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { ExtrinsicItem, TransferItem } from '@subwallet/extension-base/services/subscan-service/types';
+export declare function parseSubscanExtrinsicData(address: string, extrinsicItem: ExtrinsicItem, chainInfo: _ChainInfo): TransactionHistoryItem | null;
+export declare function parseSubscanTransferData(address: string, transferItem: TransferItem, chainInfo: _ChainInfo): TransactionHistoryItem;

package/services/history-service/subscan-history.js

@@ -0,0 +1,100 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ChainType, ExtrinsicStatus, ExtrinsicType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
+import { getExtrinsicParserKey, subscanExtrinsicParserMap, supportedExtrinsicParser } from '@subwallet/extension-base/services/history-service/helpers/subscan-extrinsic-parser-helper';
+import { decodeAddress, encodeAddress, isEthereumAddress } from '@polkadot/util-crypto';
+function autoFormatAddress(address) {
+  try {
+    if (isEthereumAddress(address)) {
+      return address;
+    } else {
+      const decoded = decodeAddress(address);
+      return encodeAddress(decoded, 42);
+    }
+  } catch (e) {
+    return '';
+  }
+}
+export function parseSubscanExtrinsicData(address, extrinsicItem, chainInfo) {
+  var _chainInfo$substrateI, _chainInfo$evmInfo, _chainInfo$substrateI2, _chainInfo$evmInfo2;
+  const extrinsicParserKey = getExtrinsicParserKey(extrinsicItem);
+  if (!supportedExtrinsicParser.includes(extrinsicParserKey)) {
+    return null;
+  }
+  const chainType = chainInfo.substrateInfo ? ChainType.SUBSTRATE : ChainType.EVM;
+  const nativeDecimals = ((_chainInfo$substrateI = chainInfo.substrateInfo) === null || _chainInfo$substrateI === void 0 ? void 0 : _chainInfo$substrateI.decimals) || ((_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.decimals) || 18;
+  const nativeSymbol = ((_chainInfo$substrateI2 = chainInfo.substrateInfo) === null || _chainInfo$substrateI2 === void 0 ? void 0 : _chainInfo$substrateI2.symbol) || ((_chainInfo$evmInfo2 = chainInfo.evmInfo) === null || _chainInfo$evmInfo2 === void 0 ? void 0 : _chainInfo$evmInfo2.symbol) || '';
+  const initData = {
+    address,
+    origin: 'subscan',
+    time: extrinsicItem.block_timestamp * 1000,
+    chainType,
+    from: address,
+    signature: extrinsicItem.signature,
+    fromName: undefined,
+    direction: TransactionDirection.SEND,
+    blockNumber: extrinsicItem.block_num,
+    blockHash: '',
+    chain: chainInfo.slug,
+    type: ExtrinsicType.UNKNOWN,
+    to: '',
+    toName: undefined,
+    extrinsicHash: extrinsicItem.extrinsic_hash,
+    amount: {
+      value: '0',
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    data: extrinsicItem.params,
+    fee: {
+      value: extrinsicItem.fee,
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    status: extrinsicItem.success ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL,
+    nonce: extrinsicItem.nonce
+  };
+  try {
+    return subscanExtrinsicParserMap[extrinsicParserKey](initData);
+  } catch (e) {
+    console.log('parseSubscanExtrinsicData error:', e, initData);
+    return null;
+  }
+}
+export function parseSubscanTransferData(address, transferItem, chainInfo) {
+  var _chainInfo$substrateI3, _chainInfo$evmInfo3, _chainInfo$substrateI4, _chainInfo$evmInfo4;
+  const chainType = chainInfo.substrateInfo ? ChainType.SUBSTRATE : ChainType.EVM;
+  const nativeDecimals = ((_chainInfo$substrateI3 = chainInfo.substrateInfo) === null || _chainInfo$substrateI3 === void 0 ? void 0 : _chainInfo$substrateI3.decimals) || ((_chainInfo$evmInfo3 = chainInfo.evmInfo) === null || _chainInfo$evmInfo3 === void 0 ? void 0 : _chainInfo$evmInfo3.decimals) || 18;
+  const nativeSymbol = ((_chainInfo$substrateI4 = chainInfo.substrateInfo) === null || _chainInfo$substrateI4 === void 0 ? void 0 : _chainInfo$substrateI4.symbol) || ((_chainInfo$evmInfo4 = chainInfo.evmInfo) === null || _chainInfo$evmInfo4 === void 0 ? void 0 : _chainInfo$evmInfo4.symbol) || '';
+  const from = autoFormatAddress(transferItem.from);
+  const to = autoFormatAddress(transferItem.to);
+  return {
+    address,
+    origin: 'subscan',
+    time: transferItem.block_timestamp * 1000,
+    chainType,
+    from,
+    fromName: transferItem.from_account_display.display,
+    direction: address === from ? TransactionDirection.SEND : TransactionDirection.RECEIVED,
+    blockNumber: transferItem.block_num,
+    blockHash: '',
+    chain: chainInfo.slug,
+    type: ExtrinsicType.TRANSFER_BALANCE,
+    to,
+    toName: transferItem.to_account_display.display,
+    extrinsicHash: transferItem.hash,
+    amount: {
+      value: transferItem.amount,
+      decimals: 0,
+      symbol: transferItem.asset_symbol
+    },
+    fee: {
+      value: transferItem.fee,
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    status: transferItem.success ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL,
+    nonce: transferItem.nonce
+  };
+}

package/services/subscan-service/index.d.ts

@@ -1,5 +1,6 @@
-import { IMultiChainBalance } from '@subwallet/extension-base/services/subscan-service/types';
+import { CrowdloanContributionsResponse, ExtrinsicItem, ExtrinsicsListResponse, IMultiChainBalance, TransferItem, TransfersListResponse } from '@subwallet/extension-base/services/subscan-service/types';
 export declare class SubscanService {
+    private subscanChainMap;
     private limitRate;
     private intervalCheck;
     private maxRetry;
@@ -7,7 +8,7 @@ export declare class SubscanService {
     private nextId;
     private isRunning;
     private getId;
-    constructor(options?: {
+    constructor(subscanChainMap: Record<string, string>, options?: {
         limitRate?: number;
         intervalCheck?: number;
         maxRetry?: number;
@@ -16,5 +17,12 @@ export declare class SubscanService {
     private postRequest;
     private addRequest;
     private process;
+    checkSupportedSubscanChain(chain: string): boolean;
+    setSubscanChainMap(subscanChainMap: Record<string, string>): void;
     getMultiChainBalance(address: string): Promise<IMultiChainBalance[]>;
+    getCrowdloanContributions(relayChain: string, address: string, page?: number): Promise<CrowdloanContributionsResponse>;
+    getExtrinsicsList(chain: string, address: string, page?: number): Promise<ExtrinsicsListResponse>;
+    fetchAllPossibleExtrinsicItems(chain: string, address: string, cbAfterEachRequest?: (items: ExtrinsicItem[]) => void): Promise<ExtrinsicItem[]>;
+    getTransfersList(chain: string, address: string, page?: number, direction?: 'sent' | 'received'): Promise<TransfersListResponse>;
+    fetchAllPossibleTransferItems(chain: string, address: string, direction?: 'sent' | 'received', cbAfterEachRequest?: (items: TransferItem[]) => void): Promise<TransferItem[]>;
 }

package/services/subscan-service/index.js

@@ -2,8 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { SWError } from '@subwallet/extension-base/background/errors/SWError';
-import SUBSCAN_CHAIN_MAP from '@subwallet/extension-base/services/subscan-service/subscan-chain-map';
+import { wait } from '@subwallet/extension-base/utils';
 import fetch from 'cross-fetch';
+const QUERY_ROW = 100;
 export class SubscanService {
   limitRate = 2; // limit per interval check
   intervalCheck = 1000; // interval check in ms
@@ -14,17 +15,18 @@ export class SubscanService {
   getId() {
     return this.nextId++;
   }
-  constructor(options) {
+  constructor(subscanChainMap, options) {
+    this.subscanChainMap = subscanChainMap;
     this.limitRate = (options === null || options === void 0 ? void 0 : options.limitRate) || this.limitRate;
     this.intervalCheck = (options === null || options === void 0 ? void 0 : options.intervalCheck) || this.intervalCheck;
     this.maxRetry = (options === null || options === void 0 ? void 0 : options.maxRetry) || this.maxRetry;
   }
   getApiUrl(chain, path) {
-    const subscanChain = SUBSCAN_CHAIN_MAP[chain];
+    const subscanChain = this.subscanChainMap[chain];
     if (!subscanChain) {
       throw new SWError('NOT_SUPPORTED', 'Chain is not supported');
     }
-    return `https://${chain}.api.subscan.io/${path}`;
+    return `https://${subscanChain}.api.subscan.io/${path}`;
   }
   postRequest(url, body) {
     return fetch(url, {
@@ -82,6 +84,12 @@ export class SubscanService {
       });
     }, this.intervalCheck);
   }
+  checkSupportedSubscanChain(chain) {
+    return !!this.subscanChainMap[chain];
+  }
+  setSubscanChainMap(subscanChainMap) {
+    this.subscanChainMap = subscanChainMap;
+  }
 
   // Implement Subscan API
   getMultiChainBalance(address) {
@@ -96,4 +104,97 @@ export class SubscanService {
       return jsonData.data;
     });
   }
+  getCrowdloanContributions(relayChain, address, page = 0) {
+    return this.addRequest(async () => {
+      const rs = await this.postRequest(this.getApiUrl(relayChain, 'api/scan/account/contributions'), {
+        include_total: true,
+        page,
+        row: QUERY_ROW,
+        who: address
+      });
+      if (rs.status !== 200) {
+        throw new SWError('SubscanService.getCrowdloanContributions', await rs.text());
+      }
+      const jsonData = await rs.json();
+      return jsonData.data;
+    });
+  }
+  getExtrinsicsList(chain, address, page = 0) {
+    return this.addRequest(async () => {
+      const rs = await this.postRequest(this.getApiUrl(chain, 'api/scan/extrinsics'), {
+        page,
+        row: QUERY_ROW,
+        address
+      });
+      if (rs.status !== 200) {
+        throw new SWError('SubscanService.getExtrinsicsList', await rs.text());
+      }
+      const jsonData = await rs.json();
+      return jsonData.data;
+    });
+  }
+  async fetchAllPossibleExtrinsicItems(chain, address, cbAfterEachRequest) {
+    let count = 0;
+    const resultMap = {};
+    const _getExtrinsicItems = async page => {
+      const res = await this.getExtrinsicsList(chain, address, page);
+      if (!res || !res.count || !res.extrinsics || !res.extrinsics.length) {
+        return;
+      }
+      if (res.count > count) {
+        count = res.count;
+      }
+      cbAfterEachRequest === null || cbAfterEachRequest === void 0 ? void 0 : cbAfterEachRequest(res.extrinsics);
+      res.extrinsics.forEach(item => {
+        resultMap[item.extrinsic_hash] = item;
+      });
+      if (Object.values(resultMap).length < count) {
+        await wait(100);
+        await _getExtrinsicItems(++page);
+      }
+    };
+    await _getExtrinsicItems(0);
+    return Object.values(resultMap);
+  }
+  getTransfersList(chain, address, page = 0, direction) {
+    const requestBody = {
+      page,
+      row: QUERY_ROW,
+      address
+    };
+    if (direction) {
+      requestBody.direction = direction;
+    }
+    return this.addRequest(async () => {
+      const rs = await this.postRequest(this.getApiUrl(chain, 'api/v2/scan/transfers'), requestBody);
+      if (rs.status !== 200) {
+        throw new SWError('SubscanService.getTransfersList', await rs.text());
+      }
+      const jsonData = await rs.json();
+      return jsonData.data;
+    });
+  }
+  async fetchAllPossibleTransferItems(chain, address, direction, cbAfterEachRequest) {
+    let count = 0;
+    const resultMap = {};
+    const _getTransferItems = async page => {
+      const res = await this.getTransfersList(chain, address, page, direction);
+      if (!res || !res.count || !res.transfers || !res.transfers.length) {
+        return;
+      }
+      if (res.count > count) {
+        count = res.count;
+      }
+      cbAfterEachRequest === null || cbAfterEachRequest === void 0 ? void 0 : cbAfterEachRequest(res.transfers);
+      res.transfers.forEach(item => {
+        resultMap[item.hash] = item;
+      });
+      if (Object.values(resultMap).length < count) {
+        await wait(100);
+        await _getTransferItems(++page);
+      }
+    };
+    await _getTransferItems(0);
+    return Object.values(resultMap);
+  }
 }

package/services/subscan-service/subscan-chain-map.d.ts

@@ -1,5 +1,11 @@
-declare const SUBSCAN_CHAIN_MAP: Record<string, string>;
-export declare const SUBSCAN_CHAIN_MAP_REVERSE: {
+/**
+ * Only use this for initiating SubscanService or unit test
+ */
+export declare const SUBSCAN_API_CHAIN_MAP: Record<string, string>;
+/**
+ * Map for token self-activation feature
+ */
+export declare const SUBSCAN_BALANCE_CHAIN_MAP: Record<string, string>;
+export declare const SUBSCAN_BALANCE_CHAIN_MAP_REVERSE: {
     [k: string]: string;
 };
-export default SUBSCAN_CHAIN_MAP;

package/services/subscan-service/subscan-chain-map.js

@@ -1,7 +1,76 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-const SUBSCAN_CHAIN_MAP = {
+/**
+ * Only use this for initiating SubscanService or unit test
+ */
+export const SUBSCAN_API_CHAIN_MAP = {
+  polkadot: 'polkadot',
+  kusama: 'kusama',
+  moonbeam: 'moonbeam',
+  pioneer: 'pioneer',
+  aleph: 'alephzero',
+  astar: 'astar',
+  statemint: 'assethub-polkadot',
+  acala: 'acala',
+  shiden: 'shiden',
+  shibuya: 'shibuya',
+  westend: 'westend',
+  rococo: 'rococo',
+  moonbase: 'moonbase',
+  moonriver: 'moonriver',
+  turing: 'turing',
+  bifrost: 'bifrost-kusama',
+  bifrost_dot: 'bifrost',
+  calamari: 'calamari',
+  parallel: 'parallel',
+  clover: 'clv',
+  hydradx_main: 'hydradx',
+  centrifuge: 'centrifuge',
+  interlay: 'interlay',
+  nodle: 'nodle',
+  darwinia2: 'darwinia',
+  polkadex: 'polkadex-parachain',
+  composableFinance: 'composable',
+  phala: 'phala',
+  crust: 'crust-parachain',
+  statemine: 'assethub-kusama',
+  karura: 'karura',
+  khala: 'khala',
+  kilt: 'spiritnet',
+  basilisk: 'basilisk',
+  altair: 'altair',
+  heiko: 'parallel-heiko',
+  kintsugi: 'kintsugi',
+  picasso: 'picasso',
+  unique_network: 'unique',
+  zeitgeist: 'zeitgeist',
+  sakura: 'sakura',
+  shadow: 'shadow',
+  robonomics: 'robonomics',
+  integritee: 'integritee',
+  crabParachain: 'crab',
+  acala_testnet: 'acala-testnet',
+  mangatax_para: 'mangatax',
+  origintrail: 'origintrail',
+  subspace_gemini_3g: 'subspace',
+  bajun: 'bajun',
+  tanganika: 'datahighway',
+  kilt_peregrine: 'kilt-testnet',
+  dockPosMainnet: 'dock',
+  polymesh: 'polymesh',
+  sora_substrate: 'sora',
+  joystream: 'joystream',
+  vara_network: 'vara',
+  krest_network: 'krest',
+  crust_mainnet: 'crust',
+  manta_network: 'manta'
+};
+
+/**
+ * Map for token self-activation feature
+ */
+export const SUBSCAN_BALANCE_CHAIN_MAP = {
   polkadot: 'polkadot',
   kusama: 'kusama',
   moonbeam: 'moonbeam',
@@ -21,7 +90,7 @@ const SUBSCAN_CHAIN_MAP = {
   clover: 'clover',
   hydradx_main: 'hydradx',
   edgeware: 'edgeware',
-  centrifuge: 'centrifuge',
+  centrifuge: 'centrifuge-parachain',
   interlay: 'interlay',
   nodle: 'nodle',
   darwinia: 'darwinia',
@@ -57,7 +126,11 @@ const SUBSCAN_CHAIN_MAP = {
   bajun: 'bajun',
   snow: 'snow',
   kilt_peregrine: 'kilt-testnet',
-  polymesh: 'polymesh'
+  polymesh: 'polymesh',
+  bifrost_dot: 'bifrost-p',
+  vara_network: 'vara',
+  bifrost: 'bifrost',
+  creditcoin: 'creditcoin',
+  joystream: 'joystream'
 };
-export const SUBSCAN_CHAIN_MAP_REVERSE = Object.fromEntries(Object.entries(SUBSCAN_CHAIN_MAP).map(([k, v]) => [v, k]));
-export default SUBSCAN_CHAIN_MAP;
+export const SUBSCAN_BALANCE_CHAIN_MAP_REVERSE = Object.fromEntries(Object.entries(SUBSCAN_BALANCE_CHAIN_MAP).map(([k, v]) => [v, k]));