@subwallet/extension-base 1.3.7-0 → 1.3.9-0

package/services/balance-service/transfer/xcm/polygonBridge.d.ts

@@ -0,0 +1,22 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+import { _NotificationInfo } from '@subwallet/extension-base/services/inapp-notification-service/interfaces';
+import { TransactionConfig } from 'web3-core';
+export interface gasStation {
+    safeLow: number;
+    standard: number;
+    fastLow: number;
+}
+export declare const POLYGON_PROOF_INDEXER: {
+    MAINNET: string;
+    TESTNET: string;
+};
+export declare const POLYGON_GAS_INDEXER: {
+    MAINNET: string;
+    TESTNET: string;
+};
+export declare function _createPolygonBridgeL1toL2Extrinsic(tokenInfo: _ChainAsset, originChainInfo: _ChainInfo, sender: string, recipientAddress: string, value: string, evmApi: _EvmApi): Promise<TransactionConfig>;
+export declare function _createPolygonBridgeL2toL1Extrinsic(tokenInfo: _ChainAsset, originChainInfo: _ChainInfo, sender: string, recipientAddress: string, value: string, evmApi: _EvmApi): Promise<TransactionConfig>;
+export declare function getClaimPolygonBridge(chainSlug: string, notification: _NotificationInfo, evmApi: _EvmApi): Promise<TransactionConfig>;
+export declare function isClaimedPolygonBridge(chainSlug: string, counter: number, sourceNetwork: number, evmApi: _EvmApi): Promise<any>;
+export declare function _isPolygonChainBridge(srcChain: string, destChain: string): boolean;

package/services/balance-service/transfer/xcm/polygonBridge.js

@@ -0,0 +1,95 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { getWeb3Contract } from '@subwallet/extension-base/koni/api/contract-handler/evm/web3';
+import { _POLYGON_BRIDGE_ABI, getPolygonBridgeContract } from '@subwallet/extension-base/koni/api/contract-handler/utils';
+import { _getContractAddressOfToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
+export const POLYGON_PROOF_INDEXER = {
+  MAINNET: 'https://api-gateway.polygon.technology/api/v3/proof/mainnet/merkle-proof',
+  TESTNET: 'https://api-gateway.polygon.technology/api/v3/proof/testnet/merkle-proof'
+};
+export const POLYGON_GAS_INDEXER = {
+  MAINNET: 'https://gasstation.polygon.technology/zkevm',
+  TESTNET: 'https://gasstation.polygon.technology/zkevm/cardona'
+};
+async function createPolygonBridgeTransaction(tokenInfo, originChainInfo, sender, recipientAddress, value, destinationNetwork, evmApi) {
+  var _priority$maxFeePerGa, _priority$maxPriority;
+  const polygonBridgeContractAddress = getPolygonBridgeContract(originChainInfo.slug);
+  const polygonBridgeContract = getWeb3Contract(polygonBridgeContractAddress, evmApi, _POLYGON_BRIDGE_ABI);
+  const tokenContract = _getContractAddressOfToken(tokenInfo) || '0x0000000000000000000000000000000000000000'; // FOR Ethereum: use null address
+
+  if (tokenContract !== '0x0000000000000000000000000000000000000000') {
+    throw new Error('Only native token transfer is supported');
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+  const transferCall = polygonBridgeContract.methods.bridgeAsset(destinationNetwork, recipientAddress, value, tokenContract, true, '0x');
+  const transferEncodedCall = transferCall.encodeABI();
+  const priority = await calculateGasFeeParams(evmApi, evmApi.chainSlug);
+  const transactionConfig = {
+    from: sender,
+    to: polygonBridgeContractAddress,
+    value: value,
+    data: transferEncodedCall,
+    gasPrice: priority.gasPrice,
+    maxFeePerGas: priority === null || priority === void 0 ? void 0 : (_priority$maxFeePerGa = priority.maxFeePerGas) === null || _priority$maxFeePerGa === void 0 ? void 0 : _priority$maxFeePerGa.toString(),
+    maxPriorityFeePerGas: priority === null || priority === void 0 ? void 0 : (_priority$maxPriority = priority.maxPriorityFeePerGas) === null || _priority$maxPriority === void 0 ? void 0 : _priority$maxPriority.toString()
+  };
+  const gasLimit = await evmApi.api.eth.estimateGas(transactionConfig).catch(() => 200000);
+  transactionConfig.gas = gasLimit.toString();
+  return transactionConfig;
+}
+export async function _createPolygonBridgeL1toL2Extrinsic(tokenInfo, originChainInfo, sender, recipientAddress, value, evmApi) {
+  return createPolygonBridgeTransaction(tokenInfo, originChainInfo, sender, recipientAddress, value, 1, evmApi);
+}
+export async function _createPolygonBridgeL2toL1Extrinsic(tokenInfo, originChainInfo, sender, recipientAddress, value, evmApi) {
+  return createPolygonBridgeTransaction(tokenInfo, originChainInfo, sender, recipientAddress, value, 0, evmApi);
+}
+export async function getClaimPolygonBridge(chainSlug, notification, evmApi) {
+  var _priority$maxFeePerGa2, _priority$maxPriority2;
+  const polygonBridgeContractAddress = getPolygonBridgeContract(chainSlug);
+  const polygonBridgeContract = getWeb3Contract(polygonBridgeContractAddress, evmApi, _POLYGON_BRIDGE_ABI);
+  const metadata = notification.metadata;
+  const isTestnet = chainSlug === COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA;
+  const proofDomain = isTestnet ? POLYGON_PROOF_INDEXER.TESTNET : POLYGON_PROOF_INDEXER.MAINNET;
+  const proofResponse = await fetch(`${proofDomain}?networkId=${metadata.sourceNetwork}&depositCount=${metadata.counter}`).then(res => res.json());
+  const proof = proofResponse.proof;
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+  const transferCall = polygonBridgeContract.methods.claimAsset(proof.merkle_proof, proof.rollup_merkle_proof, metadata.counter, proof.main_exit_root, proof.rollup_exit_root, metadata.originTokenNetwork, metadata.originTokenAddress, metadata.destinationNetwork, metadata.receiver, metadata.amounts[0], '0x');
+  const transferEncodedCall = transferCall.encodeABI();
+  const priority = await calculateGasFeeParams(evmApi, evmApi.chainSlug);
+  const transactionConfig = {
+    from: metadata.userAddress,
+    to: polygonBridgeContractAddress,
+    value: '0',
+    data: transferEncodedCall,
+    gasPrice: priority.gasPrice,
+    maxFeePerGas: (_priority$maxFeePerGa2 = priority.maxFeePerGas) === null || _priority$maxFeePerGa2 === void 0 ? void 0 : _priority$maxFeePerGa2.toString(),
+    maxPriorityFeePerGas: (_priority$maxPriority2 = priority.maxPriorityFeePerGas) === null || _priority$maxPriority2 === void 0 ? void 0 : _priority$maxPriority2.toString()
+  };
+  const gasLimit = await evmApi.api.eth.estimateGas(transactionConfig).catch(() => 200000);
+  transactionConfig.gas = gasLimit.toString();
+  return transactionConfig;
+}
+export async function isClaimedPolygonBridge(chainSlug, counter, sourceNetwork, evmApi) {
+  const polygonBridgeContractAddress = getPolygonBridgeContract(chainSlug);
+  const polygonBridgeContract = getWeb3Contract(polygonBridgeContractAddress, evmApi, _POLYGON_BRIDGE_ABI);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-member-access
+  return await polygonBridgeContract.methods.isClaimed(counter, sourceNetwork).call();
+}
+export function _isPolygonChainBridge(srcChain, destChain) {
+  if (srcChain === 'polygonzkEvm_cardona' && destChain === COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA) {
+    return true;
+  } else if (srcChain === COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA && destChain === 'polygonzkEvm_cardona') {
+    return true;
+  } else if (srcChain === 'polygonZkEvm' && destChain === COMMON_CHAIN_SLUGS.ETHEREUM) {
+    return true;
+  } else if (srcChain === COMMON_CHAIN_SLUGS.ETHEREUM && destChain === 'polygonZkEvm') {
+    return true;
+  }
+  return false;
+}

package/services/chain-online-service/constants.d.ts

@@ -0,0 +1,4 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+export declare const LATEST_CHAIN_PATCH_FETCHING_INTERVAL = 180000;
+export declare function md5HashChainInfo(data: _ChainInfo): string;
+export declare function md5HashChainAsset(data: _ChainAsset): string;

package/services/chain-online-service/constants.js

@@ -0,0 +1,23 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Md5 } from 'ts-md5';
+export const LATEST_CHAIN_PATCH_FETCHING_INTERVAL = 180000;
+export function md5HashChainInfo(data) {
+  // todo: use from chain list package later
+  const {
+    chainStatus,
+    icon,
+    providers,
+    ...chainBaseInfo
+  } = data;
+  return Md5.hashStr(JSON.stringify(chainBaseInfo));
+}
+export function md5HashChainAsset(data) {
+  // todo: use from chain list package later
+  const {
+    icon,
+    ...assetBaseInfo
+  } = data;
+  return Md5.hashStr(JSON.stringify(assetBaseInfo));
+}

package/services/chain-online-service/index.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { PatchInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { EventService } from '@subwallet/extension-base/services/event-service';
+import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
+import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+export declare class ChainOnlineService {
+    private chainService;
+    private settingService;
+    private eventService;
+    private dbService;
+    private firstApplied;
+    refreshLatestChainDataTimeOut: NodeJS.Timer | undefined;
+    constructor(chainService: ChainService, settingService: SettingService, eventService: EventService, dbService: DatabaseService);
+    validatePatchWithHash(latestPatch: PatchInfo): boolean;
+    validatePatchBeforeStore(candidateChainInfoMap: Record<string, _ChainInfo>, candidateAssetRegistry: Record<string, _ChainAsset>, latestPatch: PatchInfo): boolean;
+    handleLatestPatch(latestPatch: PatchInfo): Promise<void>;
+    private fetchLatestPatchData;
+    handleLatestPatchData(): void;
+    checkLatestData(): void;
+}

package/services/chain-online-service/index.js

@@ -0,0 +1,182 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { AssetLogoMap, ChainLogoMap } from '@subwallet/chain-list';
+import { LATEST_CHAIN_PATCH_FETCHING_INTERVAL, md5HashChainAsset, md5HashChainInfo } from '@subwallet/extension-base/services/chain-online-service/constants';
+import { filterAssetInfoMap } from '@subwallet/extension-base/services/chain-service';
+import { _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
+import { fetchPatchData, randomizeProvider } from '@subwallet/extension-base/services/chain-service/utils';
+export class ChainOnlineService {
+  constructor(chainService, settingService, eventService, dbService) {
+    this.chainService = chainService;
+    this.settingService = settingService;
+    this.eventService = eventService;
+    this.dbService = dbService;
+    this.firstApplied = false;
+  }
+  validatePatchWithHash(latestPatch) {
+    const {
+      ChainAsset,
+      ChainAssetHashMap,
+      ChainInfo,
+      ChainInfoHashMap
+    } = latestPatch;
+    for (const [chainSlug, chain] of Object.entries(ChainInfo)) {
+      if (md5HashChainInfo(chain) !== ChainInfoHashMap[chainSlug]) {
+        return false;
+      }
+    }
+    for (const [assetSlug, asset] of Object.entries(ChainAsset)) {
+      if (md5HashChainAsset(asset) !== ChainAssetHashMap[assetSlug]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  validatePatchBeforeStore(candidateChainInfoMap, candidateAssetRegistry, latestPatch) {
+    for (const [chainSlug, chainHash] of Object.entries(latestPatch.ChainInfoHashMap)) {
+      if (md5HashChainInfo(candidateChainInfoMap[chainSlug]) !== chainHash) {
+        return false;
+      }
+    }
+    for (const [assetSlug, assetHash] of Object.entries(latestPatch.ChainAssetHashMap)) {
+      if (!candidateAssetRegistry[assetSlug]) {
+        if (!latestPatch.ChainInfo[assetSlug]) {
+          // assets are not existed in case chain is removed
+          continue;
+        }
+        return false;
+      }
+      if (md5HashChainAsset(candidateAssetRegistry[assetSlug]) !== assetHash) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async handleLatestPatch(latestPatch) {
+    try {
+      var _await$this$settingSe;
+      // 1. validate fetch data with its hash
+      const isSafePatch = this.validatePatchWithHash(latestPatch);
+      const {
+        AssetLogoMap: latestAssetLogoMap,
+        ChainAsset: latestAssetInfo,
+        ChainInfo: latestChainInfo,
+        ChainLogoMap: latestChainLogoMap,
+        patchVersion: latestPatchVersion
+      } = latestPatch;
+      const currentPatchVersion = ((_await$this$settingSe = await this.settingService.getChainlistSetting()) === null || _await$this$settingSe === void 0 ? void 0 : _await$this$settingSe.patchVersion) || '';
+      const oldChainInfoMap = structuredClone(this.chainService.getChainInfoMap());
+      const oldAssetRegistry = structuredClone(this.chainService.getAssetRegistry());
+      let chainInfoMap = structuredClone(this.chainService.getChainInfoMap());
+      let assetRegistry = structuredClone(this.chainService.getAssetRegistry());
+      const currentChainStateMap = structuredClone(this.chainService.getChainStateMap());
+      const currentChainStatusMap = structuredClone(this.chainService.getChainStatusMap());
+      let addedChain = [];
+      if (isSafePatch && (!this.firstApplied || currentPatchVersion !== latestPatchVersion)) {
+        this.firstApplied = true;
+
+        // 2. merge data map
+        if (latestChainInfo && Object.keys(latestChainInfo).length > 0) {
+          chainInfoMap = Object.assign({}, oldChainInfoMap, latestChainInfo);
+          const [currentChainStateKey, newChainKey] = [Object.keys(currentChainStateMap), Object.keys(chainInfoMap)];
+          addedChain = newChainKey.filter(chain => !currentChainStateKey.includes(chain));
+          addedChain.forEach(key => {
+            currentChainStateMap[key] = {
+              active: false,
+              currentProvider: randomizeProvider(chainInfoMap[key].providers).providerKey,
+              manualTurnOff: false,
+              slug: key
+            };
+            currentChainStatusMap[key] = {
+              slug: key,
+              connectionStatus: _ChainConnectionStatus.DISCONNECTED,
+              lastUpdated: Date.now()
+            };
+          });
+        }
+        if (latestAssetInfo && Object.keys(latestAssetInfo).length > 0) {
+          assetRegistry = filterAssetInfoMap(oldChainInfoMap, Object.assign({}, oldAssetRegistry, latestAssetInfo), addedChain);
+        }
+
+        // 3. validate data before write
+        const isCorrectPatch = this.validatePatchBeforeStore(chainInfoMap, assetRegistry, latestPatch);
+
+        // 4. write to subject
+        if (isCorrectPatch) {
+          this.chainService.setChainInfoMap(chainInfoMap);
+          this.chainService.subscribeChainInfoMap().next(chainInfoMap);
+          this.chainService.setAssetRegistry(assetRegistry);
+          this.chainService.subscribeAssetRegistry().next(assetRegistry);
+          this.chainService.autoEnableTokens().then(() => {
+            this.eventService.emit('asset.updateState', '');
+          }).catch(console.error);
+          this.chainService.setChainStateMap(currentChainStateMap);
+          this.chainService.subscribeChainStateMap().next(currentChainStateMap);
+          this.chainService.subscribeChainStatusMap().next(currentChainStatusMap);
+          const storedChainInfoList = Object.keys(chainInfoMap).map(chainSlug => {
+            return {
+              ...chainInfoMap[chainSlug],
+              ...currentChainStateMap[chainSlug]
+            };
+          });
+          await this.dbService.bulkUpdateChainStore(storedChainInfoList);
+          const addedAssets = [];
+
+          // todo: the stored asset is lack of adding new assets and edited assets of old chain, update to tracking exactly updated assets from patch online.
+          Object.entries(assetRegistry).forEach(([slug, asset]) => {
+            if (addedChain.includes(asset.originChain)) {
+              addedAssets.push(asset);
+            }
+          });
+          await this.dbService.bulkUpdateAssetsStore(addedAssets);
+          if (latestChainLogoMap) {
+            const logoMap = Object.assign({}, ChainLogoMap, latestChainLogoMap);
+            this.chainService.subscribeChainLogoMap().next(logoMap);
+          }
+          if (latestAssetLogoMap) {
+            const logoMap = Object.assign({}, AssetLogoMap, latestAssetLogoMap);
+            this.chainService.subscribeAssetLogoMap().next(logoMap);
+          }
+          this.settingService.setChainlist({
+            patchVersion: latestPatchVersion
+          });
+        }
+      }
+    } catch (e) {
+      console.error('Error fetching latest patch data');
+    }
+  }
+  async fetchLatestPatchData() {
+    return await fetchPatchData();
+  }
+  handleLatestPatchData() {
+    this.fetchLatestPatchData().then(latestPatch => {
+      return new Promise(resolve => {
+        if (latestPatch && !this.chainService.getlockChainInfoMap()) {
+          this.eventService.waitAssetReady.then(() => {
+            this.chainService.setLockChainInfoMap(true);
+            this.handleLatestPatch(latestPatch).then(() => this.chainService.setLockChainInfoMap(false)).catch(e => {
+              this.chainService.setLockChainInfoMap(false);
+              console.error('Error update latest patch', e);
+            }).finally(resolve);
+          }).catch(e => {
+            console.error('Asset fail to ready', e);
+            resolve();
+          });
+        } else {
+          resolve();
+        }
+      });
+    }).catch(e => {
+      console.error('Error get latest patch or data map is locking', e);
+    }).finally(() => {
+      this.eventService.emit('asset.online.ready', true);
+    });
+  }
+  checkLatestData() {
+    clearInterval(this.refreshLatestChainDataTimeOut);
+    this.handleLatestPatchData();
+    this.refreshLatestChainDataTimeOut = setInterval(this.handleLatestPatchData.bind(this), LATEST_CHAIN_PATCH_FETCHING_INTERVAL);
+  }
+}

package/services/chain-service/constants.d.ts

@@ -82,6 +82,7 @@ export declare const _XCM_CHAIN_GROUP: {
     polkadotXcmSpecialCases: string[];
     xcmPallet: string[];
 };
+export declare const SUFFICIENT_CHAIN: string[];
 export declare const _XCM_TYPE: {
     RP: string;
     PP: string;

package/services/chain-service/constants.js

@@ -270,6 +270,7 @@ export const _XCM_CHAIN_GROUP = {
   // default is xTokens pallet
 };
 
+export const SUFFICIENT_CHAIN = ['astar', 'calamari', 'parallel', 'darwinia2', 'crabParachain', 'pangolin', 'statemint', 'moonriver', 'shiden', 'moonbeam', 'statemine', 'liberland', 'dentnet', 'phala', 'crust', 'dbcchain', 'rococo_assethub'];
 export const _XCM_TYPE = {
   RP: `${_SubstrateChainType.RELAYCHAIN}-${_SubstrateChainType.PARACHAIN}`,
   // DMP

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

@@ -8,6 +8,7 @@ import { IMetadataItem } from '@subwallet/extension-base/services/storage-servic
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { BehaviorSubject, Subject } from 'rxjs';
 import { ExtraInfo } from '@polkadot-api/merkleize-metadata';
+export declare const filterAssetInfoMap: (chainInfo: Record<string, _ChainInfo>, assets: Record<string, _ChainAsset>, addedChains?: string[]) => Record<string, _ChainAsset>;
 export declare class ChainService {
     private dataMap;
     private dbService;
@@ -29,8 +30,6 @@ export declare class ChainService {
     private assetLogoMapSubject;
     private chainLogoMapSubject;
     private ledgerGenericAllowChainsSubject;
-    private assetMapPatch;
-    private assetLogoPatch;
     private store;
     private assetSettingSubject;
     private logger;
@@ -44,6 +43,8 @@ export declare class ChainService {
     subscribeSwapRefMap(): Subject<Record<string, _AssetRef>>;
     get xcmRefMap(): Record<string, _AssetRef>;
     get swapRefMap(): Record<string, _AssetRef>;
+    getlockChainInfoMap(): boolean;
+    setLockChainInfoMap(isLock: boolean): void;
     getEvmApi(slug: string): import("./handler/EvmApi").EvmApi;
     getEvmApiMap(): Record<string, import("./handler/EvmApi").EvmApi>;
     getSubstrateApi(slug: string): _SubstrateApi;
@@ -61,16 +62,19 @@ export declare class ChainService {
     subscribeChainStateMap(): Subject<Record<string, _ChainState>>;
     subscribeChainStatusMap(): BehaviorSubject<Record<string, _ChainApiStatus>>;
     getAssetRegistry(): Record<string, _ChainAsset>;
+    setAssetRegistry(assetRegistry: Record<string, _ChainAsset>): void;
     getMultiChainAssetMap(): Record<string, _MultiChainAsset>;
     getSmartContractTokens(): Record<string, _ChainAsset>;
     getAssetHubToken(): Record<string, _ChainAsset>;
     getChainInfoMap(): Record<string, _ChainInfo>;
+    setChainInfoMap(chainInfoMap: Record<string, _ChainInfo>): void;
     getEvmChainInfoMap(): Record<string, _ChainInfo>;
     getSubstrateChainInfoMap(): Record<string, _ChainInfo>;
     getAllPriceIds(): string[];
     getNativeTokenInfo(chainSlug: string): _ChainAsset;
     getAssetRefMap(): Record<string, _AssetRef>;
     getChainStateMap(): Record<string, _ChainState>;
+    setChainStateMap(chainStateMap: Record<string, _ChainState>): void;
     getChainStateByKey(key: string): _ChainState;
     getChainStatusMap(): Record<string, _ChainApiStatus>;
     getChainStatusByKey(key: string): _ChainApiStatus;
@@ -99,9 +103,6 @@ export declare class ChainService {
     checkLatestData(): void;
     stopCheckLatestChainData(): void;
     handleLatestChainData(latestChainInfo: _ChainInfo[]): void;
-    handleLatestAssetRef(latestBlockedAssetRefList: string[], latestAssetRefMap: Record<string, _AssetRef> | null): void;
-    handleLatestPriceId(latestPriceIds: Record<string, string | null>): void;
-    handleLatestAssetData(latestAssetInfo: Record<string, _ChainAsset> | null, latestAssetLogoMap: Record<string, string> | null): void;
     autoEnableTokens(): Promise<void>;
     handleLatestLedgerGenericAllowChains(latestledgerGenericAllowChains: string[]): void;
     handleLatestData(): void;
@@ -115,9 +116,7 @@ export declare class ChainService {
     disableChain(chainSlug: string): boolean;
     private checkExistedPredefinedChain;
     private fetchLatestChainData;
-    private fetchLatestAssetData;
     private fetchLatestPriceIdsData;
-    private fetchLatestAssetRef;
     private fetchLatestLedgerGenericAllowChains;
     private initChains;
     private initAssetRegistry;