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

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

@@ -0,0 +1,190 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChainOnlineService = void 0;
+var _chainList = require("@subwallet/chain-list");
+var _constants = require("@subwallet/extension-base/services/chain-online-service/constants");
+var _chainService = require("@subwallet/extension-base/services/chain-service");
+var _types = require("@subwallet/extension-base/services/chain-service/types");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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 ((0, _constants.md5HashChainInfo)(chain) !== ChainInfoHashMap[chainSlug]) {
+        return false;
+      }
+    }
+    for (const [assetSlug, asset] of Object.entries(ChainAsset)) {
+      if ((0, _constants.md5HashChainAsset)(asset) !== ChainAssetHashMap[assetSlug]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  validatePatchBeforeStore(candidateChainInfoMap, candidateAssetRegistry, latestPatch) {
+    for (const [chainSlug, chainHash] of Object.entries(latestPatch.ChainInfoHashMap)) {
+      if ((0, _constants.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 ((0, _constants.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: (0, _utils.randomizeProvider)(chainInfoMap[key].providers).providerKey,
+              manualTurnOff: false,
+              slug: key
+            };
+            currentChainStatusMap[key] = {
+              slug: key,
+              connectionStatus: _types._ChainConnectionStatus.DISCONNECTED,
+              lastUpdated: Date.now()
+            };
+          });
+        }
+        if (latestAssetInfo && Object.keys(latestAssetInfo).length > 0) {
+          assetRegistry = (0, _chainService.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(_ref => {
+            let [slug, asset] = _ref;
+            if (addedChain.includes(asset.originChain)) {
+              addedAssets.push(asset);
+            }
+          });
+          await this.dbService.bulkUpdateAssetsStore(addedAssets);
+          if (latestChainLogoMap) {
+            const logoMap = Object.assign({}, _chainList.ChainLogoMap, latestChainLogoMap);
+            this.chainService.subscribeChainLogoMap().next(logoMap);
+          }
+          if (latestAssetLogoMap) {
+            const logoMap = Object.assign({}, _chainList.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 (0, _utils.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), _constants.LATEST_CHAIN_PATCH_FETCHING_INTERVAL);
+  }
+}
+exports.ChainOnlineService = ChainOnlineService;

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

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ChainService = void 0;
+exports.filterAssetInfoMap = exports.ChainService = void 0;
 var _chainList = require("@subwallet/chain-list");
 var _types = require("@subwallet/chain-list/types");
 var _constants = require("@subwallet/extension-base/services/chain-service/constants");
@@ -30,29 +30,13 @@ const filterChainInfoMap = (data, ignoredChains) => {
   }));
 };
 const ignoredList = ['bevm', 'bevmTest', 'bevm_testnet', 'layerEdge_testnet', 'merlinEvm', 'botanixEvmTest', 'syscoin_evm', 'syscoin_evm_testnet', 'rollux_evm', 'rollux_testnet', 'boolAlpha', 'boolBeta_testnet', 'core', 'satoshivm', 'satoshivm_testnet', 'storyPartner_testnet'];
-const filterAssetInfoMap = (chainInfo, assets) => {
+const filterAssetInfoMap = (chainInfo, assets, addedChains) => {
   return Object.fromEntries(Object.entries(assets).filter(_ref2 => {
     let [, info] = _ref2;
-    return chainInfo[info.originChain];
+    return chainInfo[info.originChain] || (addedChains === null || addedChains === void 0 ? void 0 : addedChains.includes(info.originChain));
   }));
 };
-
-// const rawAssetRefMap = (assetRefMap: Record<string, _AssetRef>) => {
-//   const result: Record<string, _AssetRef> = {};
-//
-//   Object.entries(assetRefMap).forEach(([key, assetRef]) => {
-//     const originChainInfo = ChainInfoMap[assetRef.srcChain];
-//     const destChainInfo = ChainInfoMap[assetRef.destChain];
-//     const isSnowBridgeXcm = assetRef.path === _AssetRefPath.XCM && _isSnowBridgeXcm(originChainInfo, destChainInfo);
-//
-//     if (!isSnowBridgeXcm) {
-//       result[key] = assetRef;
-//     }
-//   });
-//
-//   return result;
-// };
-
+exports.filterAssetInfoMap = filterAssetInfoMap;
 class ChainService {
   dataMap = {
     chainInfoMap: {},
@@ -77,8 +61,6 @@ class ChainService {
   assetLogoMapSubject = new _rxjs.BehaviorSubject(_chainList.AssetLogoMap);
   chainLogoMapSubject = new _rxjs.BehaviorSubject(_chainList.ChainLogoMap);
   ledgerGenericAllowChainsSubject = new _rxjs.BehaviorSubject([]);
-  assetMapPatch = JSON.stringify({});
-  assetLogoPatch = JSON.stringify({});
 
   // Todo: Update to new store indexed DB
   store = new _AssetSetting.default();
@@ -141,6 +123,12 @@ class ChainService {
     });
     return result;
   }
+  getlockChainInfoMap() {
+    return this.lockChainInfoMap;
+  }
+  setLockChainInfoMap(isLock) {
+    this.lockChainInfoMap = isLock;
+  }
   getEvmApi(slug) {
     return this.evmChainHandler.getEvmApiByChain(slug);
   }
@@ -189,6 +177,9 @@ class ChainService {
   getAssetRegistry() {
     return this.dataMap.assetRegistry;
   }
+  setAssetRegistry(assetRegistry) {
+    this.dataMap.assetRegistry = assetRegistry;
+  }
   getMultiChainAssetMap() {
     return _chainList.MultiChainAssetMap;
   }
@@ -213,6 +204,9 @@ class ChainService {
   getChainInfoMap() {
     return this.dataMap.chainInfoMap;
   }
+  setChainInfoMap(chainInfoMap) {
+    this.dataMap.chainInfoMap = chainInfoMap;
+  }
   getEvmChainInfoMap() {
     const result = {};
     Object.values(this.getChainInfoMap()).forEach(chainInfo => {
@@ -269,6 +263,9 @@ class ChainService {
   getChainStateMap() {
     return this.dataMap.chainStateMap;
   }
+  setChainStateMap(chainStateMap) {
+    this.dataMap.chainStateMap = chainStateMap;
+  }
   getChainStateByKey(key) {
     return this.dataMap.chainStateMap[key];
   }
@@ -521,10 +518,10 @@ class ChainService {
     await this.initChains();
     this.chainInfoMapSubject.next(this.getChainInfoMap());
     this.assetRegistrySubject.next(this.getAssetRegistry());
+    this.initAssetRefMap();
     this.xcmRefMapSubject.next(this.xcmRefMap);
     await this.initApis();
     await this.initAssetSettings();
-    this.initAssetRefMap();
     await this.autoEnableTokens();
   }
   initAssetRefMap() {
@@ -557,80 +554,25 @@ class ChainService {
       console.error('Error fetching latest chain data');
     }
   }
-  handleLatestAssetRef(latestBlockedAssetRefList, latestAssetRefMap) {
-    const updatedAssetRefMap = {
-      ..._chainList.AssetRefMap
-    };
-    if (latestAssetRefMap) {
-      for (const [assetRefKey, assetRef] of Object.entries(latestAssetRefMap)) {
-        updatedAssetRefMap[assetRefKey] = assetRef;
-      }
-    }
-    latestBlockedAssetRefList.forEach(blockedAssetRef => {
-      delete updatedAssetRefMap[blockedAssetRef];
-    });
-    this.dataMap.assetRefMap = updatedAssetRefMap;
-    this.xcmRefMapSubject.next(this.xcmRefMap);
-    this.swapRefMapSubject.next(this.swapRefMap);
-    this.logger.log('Finished updating latest asset ref');
-  }
-  handleLatestPriceId(latestPriceIds) {
-    let isUpdated = false;
-    Object.entries(latestPriceIds).forEach(_ref8 => {
-      let [slug, priceId] = _ref8;
-      if (this.dataMap.assetRegistry[slug] && this.dataMap.assetRegistry[slug].priceId !== priceId) {
-        isUpdated = true;
-        this.dataMap.assetRegistry[slug].priceId = priceId;
-      }
-    });
-    if (isUpdated) {
-      this.assetRegistrySubject.next(this.dataMap.assetRegistry);
-      this.eventService.emit('asset.updateState', '');
-    }
-    this.logger.log('Finished updating latest price IDs');
-  }
-  handleLatestAssetData(latestAssetInfo, latestAssetLogoMap) {
-    try {
-      if (latestAssetInfo) {
-        const latestAssetPatch = JSON.stringify(latestAssetInfo);
-        if (this.assetMapPatch !== latestAssetPatch) {
-          const assetRegistry = filterAssetInfoMap(this.getChainInfoMap(), Object.assign({}, this.dataMap.assetRegistry, latestAssetInfo));
-          this.assetMapPatch = latestAssetPatch;
-          this.dataMap.assetRegistry = assetRegistry;
-          this.assetRegistrySubject.next(assetRegistry);
-          this.autoEnableTokens().then(() => {
-            this.eventService.emit('asset.updateState', '');
-          }).catch(console.error);
-        }
-      }
-      if (latestAssetLogoMap) {
-        const latestAssetLogoPatch = JSON.stringify(latestAssetLogoMap);
-        if (this.assetLogoPatch !== latestAssetLogoPatch) {
-          const logoMap = {
-            ..._chainList.AssetLogoMap,
-            ...latestAssetLogoMap
-          };
-          this.assetLogoPatch = latestAssetLogoPatch;
-          this.assetLogoMapSubject.next(logoMap);
-        }
-      }
-      if (latestAssetLogoMap) {
-        const latestAssetLogoPatch = JSON.stringify(latestAssetLogoMap);
-        if (this.assetLogoPatch !== latestAssetLogoPatch) {
-          const logoMap = {
-            ..._chainList.AssetLogoMap,
-            ...latestAssetLogoMap
-          };
-          this.assetLogoPatch = latestAssetLogoPatch;
-          this.assetLogoMapSubject.next(logoMap);
-        }
-      }
-    } catch (e) {
-      console.error('Error fetching latest asset data');
-    }
-    this.eventService.emit('asset.online.ready', true);
-    this.logger.log('Finished updating latest asset');
-  }
+
+  // handleLatestPriceId (latestPriceIds: Record<string, string | null>) {
+  //   let isUpdated = false;
+  //
+  //   Object.entries(latestPriceIds).forEach(([slug, priceId]) => {
+  //     if (this.dataMap.assetRegistry[slug] && this.dataMap.assetRegistry[slug].priceId !== priceId) {
+  //       isUpdated = true;
+  //       this.dataMap.assetRegistry[slug].priceId = priceId;
+  //     }
+  //   });
+  //
+  //   if (isUpdated) {
+  //     this.assetRegistrySubject.next(this.dataMap.assetRegistry);
+  //     this.eventService.emit('asset.updateState', '');
+  //   }
+  //
+  //   this.logger.log('Finished updating latest price IDs');
+  // }
+
   async autoEnableTokens() {
     const autoEnableTokens = Object.values(this.dataMap.assetRegistry).filter(asset => (0, _utils._isAssetAutoEnable)(asset));
     const assetSettings = this.assetSettingSubject.value;
@@ -664,22 +606,19 @@ class ChainService {
     this.logger.log('Finished updating latest ledger generic allow chains');
   }
   handleLatestData() {
-    this.fetchLatestAssetData().then(_ref9 => {
-      let [latestAssetInfo, latestAssetLogoMap] = _ref9;
-      this.eventService.waitAssetReady.then(() => {
-        this.handleLatestAssetData(latestAssetInfo, latestAssetLogoMap);
-      }).catch(console.error);
-    }).catch(console.error);
     this.fetchLatestChainData().then(latestChainInfo => {
+      this.lockChainInfoMap = true; // do not need to check current lockChainInfoMap because all remains action is fast enough and don't affect this feature.
       this.handleLatestChainData(latestChainInfo);
-    }).catch(console.error);
-    this.fetchLatestAssetRef().then(_ref10 => {
-      let [latestAssetRef, latestAssetRefMap] = _ref10;
-      this.handleLatestAssetRef(latestAssetRef, latestAssetRefMap);
-    }).catch(console.error);
-    this.fetchLatestPriceIdsData().then(latestPriceIds => {
-      this.handleLatestPriceId(latestPriceIds);
-    }).catch(console.error);
+      this.lockChainInfoMap = false;
+    }).catch(e => {
+      this.lockChainInfoMap = false;
+      console.error('Error update latest chain data', e);
+    });
+
+    // this.fetchLatestPriceIdsData().then((latestPriceIds) => {
+    //   this.handleLatestPriceId(latestPriceIds);
+    // }).catch(console.error);
+
     this.fetchLatestLedgerGenericAllowChains().then(latestledgerGenericAllowChains => {
       this.handleLatestLedgerGenericAllowChains(latestledgerGenericAllowChains);
     }).catch(console.error);
@@ -687,12 +626,12 @@ class ChainService {
   async initApis() {
     const chainInfoMap = this.getChainInfoMap();
     const chainStateMap = this.getChainStateMap();
-    await Promise.all(Object.entries(chainInfoMap).filter(_ref11 => {
+    await Promise.all(Object.entries(chainInfoMap).filter(_ref8 => {
       var _chainStateMap$slug;
-      let [slug] = _ref11;
+      let [slug] = _ref8;
       return (_chainStateMap$slug = chainStateMap[slug]) === null || _chainStateMap$slug === void 0 ? void 0 : _chainStateMap$slug.active;
-    }).map(_ref12 => {
-      let [, chainInfo] = _ref12;
+    }).map(_ref9 => {
+      let [, chainInfo] = _ref9;
       try {
         return this.initApiForChain(chainInfo);
       } catch (e) {
@@ -939,17 +878,10 @@ class ChainService {
     // }
   }
 
-  async fetchLatestAssetData() {
-    return await Promise.all([(0, _utils.fetchPatchData)('ChainAsset.json'), (0, _utils.fetchPatchData)('AssetLogoMap.json')]);
-  }
-
   // @ts-ignore
   async fetchLatestPriceIdsData() {
     return await (0, _utils2.fetchStaticData)('chain-assets/price-map');
   }
-  async fetchLatestAssetRef() {
-    return await Promise.all([(0, _utils2.fetchStaticData)('chain-assets/disabled-xcm-channels'), (0, _utils.fetchPatchData)('AssetRef.json')]);
-  }
   async fetchLatestLedgerGenericAllowChains() {
     return (await (0, _utils2.fetchStaticData)('chains/ledger-generic-allow-chains')) || [];
   }
@@ -1097,13 +1029,41 @@ class ChainService {
             });
           }
         } else {
-          // Todo: Remove chain from storage
+          var _storedChainInfo$bitc2;
+          // added chain from patch
+          this.dataMap.chainStateMap[storedSlug] = {
+            currentProvider: storedChainInfo.currentProvider,
+            slug: storedSlug,
+            active: storedChainInfo.active,
+            manualTurnOff
+          };
+          this.updateChainConnectionStatus(storedSlug, _types3._ChainConnectionStatus.DISCONNECTED);
+          newStorageData.push({
+            ...storedChainSettingMap[storedSlug],
+            active: storedChainInfo.active,
+            currentProvider: storedChainInfo.currentProvider,
+            manualTurnOff
+          });
+          mergedChainInfoMap[storedSlug] = {
+            slug: storedSlug,
+            name: storedChainInfo.name,
+            providers: storedChainInfo.providers,
+            evmInfo: storedChainInfo.evmInfo,
+            substrateInfo: storedChainInfo.substrateInfo,
+            bitcoinInfo: (_storedChainInfo$bitc2 = storedChainInfo.bitcoinInfo) !== null && _storedChainInfo$bitc2 !== void 0 ? _storedChainInfo$bitc2 : null,
+            tonInfo: storedChainInfo.tonInfo,
+            isTestnet: storedChainInfo.isTestnet,
+            chainStatus: storedChainInfo.chainStatus,
+            icon: storedChainInfo.icon,
+            extraInfo: storedChainInfo.extraInfo
+          };
+          deprecatedChainMap[storedSlug] = storedSlug; // todo: set a better name
         }
       }
 
       // Fill in the missing chainState and storageData (new chains never before seen)
-      Object.entries(mergedChainInfoMap).forEach(_ref13 => {
-        let [slug, chainInfo] = _ref13;
+      Object.entries(mergedChainInfoMap).forEach(_ref10 => {
+        let [slug, chainInfo] = _ref10;
         if (!(slug in this.dataMap.chainStateMap)) {
           this.dataMap.chainStateMap[slug] = {
             currentProvider: Object.keys(chainInfo.providers)[0],
@@ -1181,8 +1141,8 @@ class ChainService {
     // Fill out zk assets from finalAssetRegistry if not supported
     if (!_utils2.MODULE_SUPPORT.MANTA_ZK) {
       const zkAssets = [];
-      Object.entries(finalAssetRegistry).forEach(_ref14 => {
-        let [slug, assets] = _ref14;
+      Object.entries(finalAssetRegistry).forEach(_ref11 => {
+        let [slug, assets] = _ref11;
         if ((0, _utils._isMantaZkAsset)(assets)) {
           zkAssets.push(slug);
           delete finalAssetRegistry[slug];

package/cjs/services/chain-service/utils/index.js

@@ -730,8 +730,6 @@ function updateLatestChainInfo(currentDataMap, latestChainInfoList) {
     }
     if (currentChainInfo) {
       needUpdate = true;
-      currentChainInfo.extraInfo = latestChainInfo.extraInfo;
-      currentChainInfo.chainStatus = latestChainInfo.chainStatus;
       if (Object.keys(currentChainInfo.providers).length === 0) {
         currentChainInfo.chainStatus = _types._ChainStatus.INACTIVE;
       }

package/cjs/services/chain-service/utils/patch.js

@@ -10,10 +10,14 @@ exports.fetchPatchData = fetchPatchData;
 const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev';
-const ChainListVersion = '0.2.62';
-async function fetchPatchData(slug) {
+const fetchFile = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'list.json' : 'preview.json';
+const ChainListVersion = '0.2.95'; // update this when build chainlist
+
+// todo: move this interface to chainlist
+
+async function fetchPatchData() {
   try {
-    const fetchPromise = fetch(`${fetchDomain}/patch/${ChainListVersion}/${slug}`);
+    const fetchPromise = fetch(`${fetchDomain}/patch/${ChainListVersion}/${fetchFile}`);
     const timeout = new Promise(resolve => {
       const id = setTimeout(() => {
         clearTimeout(id);

package/cjs/services/fee-service/utils/index.js

@@ -8,6 +8,7 @@ exports.recalculateGasPrice = exports.parseInfuraFee = exports.fetchSubWalletFee
 var _constants = require("@subwallet/extension-base/constants");
 var _utils = require("@subwallet/extension-base/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _polygonBridge = require("../../balance-service/transfer/xcm/polygonBridge");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
@@ -106,6 +107,19 @@ const calculateGasFeeParams = async function (web3, networkKey) {
     } catch (e) {}
   }
   try {
+    if (networkKey === 'polygonzkEvm_cardona' || networkKey === 'polygonZkEvm') {
+      const isTestnet = networkKey === 'polygonzkEvm_cardona';
+      const gasDomain = isTestnet ? _polygonBridge.POLYGON_GAS_INDEXER.TESTNET : _polygonBridge.POLYGON_GAS_INDEXER.MAINNET;
+      const gasResponse = await fetch(`${gasDomain}`).then(res => res.json());
+      const gasPriceInWei = gasResponse.standard * 1e9 + 200000;
+      return {
+        gasPrice: gasPriceInWei.toString(),
+        maxFeePerGas: undefined,
+        maxPriorityFeePerGas: undefined,
+        baseGasFee: undefined,
+        busyNetwork: false
+      };
+    }
     const numBlock = 20;
     const rewardPercent = [];
     for (let i = 0; i <= 100; i = i + 5) {

package/cjs/services/inapp-notification-service/consts.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ONE_DAY_MILLISECOND = exports.NotificationTitleMap = exports.NotificationDescriptionMap = void 0;
-var _interfaces = require("@subwallet/extension-base/services/inapp-notification-service/interfaces");
-var _utils = require("@subwallet/extension-base/services/inapp-notification-service/utils");
+var _interfaces = require("./interfaces");
+var _utils = require("./utils");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -15,7 +15,8 @@ const NotificationTitleMap = {
   [_interfaces.NotificationActionType.SEND]: '[{{accountName}}] SEND {{tokenSymbol}}',
   [_interfaces.NotificationActionType.RECEIVE]: '[{{accountName}}] RECEIVE {{tokenSymbol}}',
   [_interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_AVAIL]: '[{{accountName}}] CLAIM {{tokenSymbol}}',
-  [_interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM]: '[{{accountName}}] CLAIM {{tokenSymbol}}'
+  [_interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM]: '[{{accountName}}] CLAIM {{tokenSymbol}}',
+  [_interfaces.NotificationActionType.CLAIM_POLYGON_BRIDGE]: '[{{accountName}}] CLAIM {{tokenSymbol}}'
 };
 exports.NotificationTitleMap = NotificationTitleMap;
 const NotificationDescriptionMap = {
@@ -24,7 +25,8 @@ const NotificationDescriptionMap = {
   [_interfaces.NotificationActionType.SEND]: _utils.getSendDescription,
   [_interfaces.NotificationActionType.RECEIVE]: _utils.getReceiveDescription,
   [_interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_AVAIL]: _utils.getAvailBridgeClaimDescription,
-  [_interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM]: _utils.getAvailBridgeClaimDescription
+  [_interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM]: _utils.getAvailBridgeClaimDescription,
+  [_interfaces.NotificationActionType.CLAIM_POLYGON_BRIDGE]: _utils.getPolygonBridgeClaimDescription
 };
 exports.NotificationDescriptionMap = NotificationDescriptionMap;
 const ONE_DAY_MILLISECOND = 1000 * 24 * 60 * 60;