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

package/cjs/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '1.3.7-0'
+  version: '1.3.9-0'
 };
 exports.packageInfo = packageInfo;

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

@@ -17,6 +17,7 @@ var _utils2 = require("@subwallet/extension-base/utils");
 var _keyring = require("@subwallet/keyring");
 var _types2 = require("@subwallet/keyring/types");
 var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _i18next = require("i18next");
 var _rxjs = require("rxjs");
 var _util = require("@polkadot/util");
@@ -170,7 +171,10 @@ class BalanceService {
   }
 
   /** Subscribe token free balance of an address on chain */
-  async subscribeTransferableBalance(address, chain, tokenSlug, extrinsicType, callback) {
+  async subscribeBalance(address, chain, tokenSlug) {
+    let balanceType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'transferable';
+    let extrinsicType = arguments.length > 4 ? arguments[4] : undefined;
+    let callback = arguments.length > 5 ? arguments[5] : undefined;
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
     const chainState = this.state.chainService.getChainStateByKey(chain);
     if (!chainInfo || !chainState || !chainState.active) {
@@ -199,10 +203,18 @@ class BalanceService {
       let unsub = _util.noop;
       unsub = (0, _helpers.subscribeBalance)([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, result => {
         const rs = result[0];
+        let value;
+        switch (balanceType) {
+          case 'total':
+            value = new _bignumber.default(rs.free).plus(new _bignumber.default(rs.locked)).toFixed();
+            break;
+          default:
+            value = rs.free;
+        }
         if (rs.tokenSlug === tSlug && rs.state !== _KoniTypes.APIItemState.PENDING) {
           hasError = false;
           const balance = {
-            value: rs.free,
+            value,
             decimals: tokenInfo.decimals || 0,
             symbol: tokenInfo.symbol,
             metadata: rs.metadata
@@ -226,6 +238,12 @@ class BalanceService {
       }, 9999);
     });
   }
+  async subscribeTransferableBalance(address, chain, tokenSlug, extrinsicType, callback) {
+    return this.subscribeBalance(address, chain, tokenSlug, 'transferable', extrinsicType, callback);
+  }
+  async subscribeTotalBalance(address, chain, tokenSlug, extrinsicType, callback) {
+    return this.subscribeBalance(address, chain, tokenSlug, 'total', extrinsicType, callback);
+  }
 
   /**
    * @public
@@ -242,6 +260,10 @@ class BalanceService {
     const [, balance] = await this.subscribeTransferableBalance(address, chain, tokenSlug, extrinsicType);
     return balance;
   }
+  async getTotalBalance(address, chain, tokenSlug, extrinsicType) {
+    const [, balance] = await this.subscribeTotalBalance(address, chain, tokenSlug, extrinsicType);
+    return balance;
+  }
 
   /** Remove balance from the subject object by addresses */
   removeBalanceByAddresses(addresses) {

package/cjs/services/balance-service/transfer/smart-contract.js

@@ -15,6 +15,7 @@ var _utils2 = require("@subwallet/extension-base/koni/api/contract-handler/wasm/
 var _constants = require("@subwallet/extension-base/services/chain-service/constants");
 var _utils3 = require("@subwallet/extension-base/services/fee-service/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _i18next = require("i18next");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
@@ -88,11 +89,21 @@ async function getERC721Transaction(web3Api, chain, contractAddress, senderAddre
   var _priority$maxFeePerGa3, _priority$maxPriority3;
   // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
   const contract = new web3Api.api.eth.Contract(_utils._ERC721_ABI, contractAddress);
-  const [gasLimit, priority] = await Promise.all([
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
-  contract.methods.safeTransferFrom(senderAddress, recipientAddress, tokenId).estimateGas({
-    from: senderAddress
-  }), (0, _utils3.calculateGasFeeParams)(web3Api, chain)]);
+  let gasLimit;
+  let priority;
+  try {
+    [gasLimit, priority] = await Promise.all([
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    contract.methods.safeTransferFrom(senderAddress, recipientAddress, tokenId).estimateGas({
+      from: senderAddress
+    }), (0, _utils3.calculateGasFeeParams)(web3Api, chain)]);
+  } catch (e) {
+    const error = e;
+    if (error.message.includes('transfer to non ERC721Receiver implementer')) {
+      error.message = (0, _i18next.t)('Unable to send. NFT not supported on recipient address');
+    }
+    throw error;
+  }
   return {
     from: senderAddress,
     gasPrice: priority.gasPrice,

package/cjs/services/balance-service/transfer/xcm/index.js

@@ -4,10 +4,11 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getXcmMockTxFee = exports.createXcmExtrinsic = exports.createSnowBridgeExtrinsic = exports.createAvailBridgeTxFromEth = exports.createAvailBridgeExtrinsicFromAvail = void 0;
+exports.getXcmMockTxFee = exports.createXcmExtrinsic = exports.createSnowBridgeExtrinsic = exports.createPolygonBridgeExtrinsic = exports.createAvailBridgeTxFromEth = exports.createAvailBridgeExtrinsicFromAvail = void 0;
 var _xcmParser = require("@subwallet/extension-base/core/substrate/xcm-parser");
 var _availBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge");
 var _polkadotXcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm/polkadotXcm");
+var _polygonBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge");
 var _snowBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/snowBridge");
 var _xcmPallet = require("@subwallet/extension-base/services/balance-service/transfer/xcm/xcmPallet");
 var _xTokens = require("@subwallet/extension-base/services/balance-service/transfer/xcm/xTokens");
@@ -100,6 +101,35 @@ const createAvailBridgeExtrinsicFromAvail = async _ref4 => {
   return await (0, _availBridge.getAvailBridgeExtrinsicFromAvail)(recipient, sendingValue, substrateApi);
 };
 exports.createAvailBridgeExtrinsicFromAvail = createAvailBridgeExtrinsicFromAvail;
+const createPolygonBridgeExtrinsic = async _ref5 => {
+  let {
+    chainInfoMap,
+    destinationTokenInfo,
+    evmApi,
+    originTokenInfo,
+    recipient,
+    sender,
+    sendingValue
+  } = _ref5;
+  const originChainInfo = chainInfoMap[originTokenInfo.originChain];
+  const destinationChainInfo = chainInfoMap[destinationTokenInfo.originChain];
+  if (!(0, _xcmParser._isPolygonBridgeXcm)(originChainInfo, destinationChainInfo)) {
+    throw new Error('This is not a valid PolygonBridge transfer');
+  }
+  if (!evmApi) {
+    throw Error('Evm API is not available');
+  }
+  if (!sender) {
+    throw Error('Sender is required');
+  }
+  const sourceChain = originChainInfo.slug;
+  if (sourceChain === 'polygonzkEvm_cardona' || sourceChain === 'polygonZkEvm') {
+    return (0, _polygonBridge._createPolygonBridgeL2toL1Extrinsic)(originTokenInfo, originChainInfo, sender, recipient, sendingValue, evmApi);
+  } else {
+    return (0, _polygonBridge._createPolygonBridgeL1toL2Extrinsic)(originTokenInfo, originChainInfo, sender, recipient, sendingValue, evmApi);
+  }
+};
+exports.createPolygonBridgeExtrinsic = createPolygonBridgeExtrinsic;
 const getXcmMockTxFee = async (substrateApi, chainInfoMap, originTokenInfo, destinationTokenInfo) => {
   try {
     var _paymentInfo$partialF;

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

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.POLYGON_PROOF_INDEXER = exports.POLYGON_GAS_INDEXER = void 0;
+exports._createPolygonBridgeL1toL2Extrinsic = _createPolygonBridgeL1toL2Extrinsic;
+exports._createPolygonBridgeL2toL1Extrinsic = _createPolygonBridgeL2toL1Extrinsic;
+exports._isPolygonChainBridge = _isPolygonChainBridge;
+exports.getClaimPolygonBridge = getClaimPolygonBridge;
+exports.isClaimedPolygonBridge = isClaimedPolygonBridge;
+var _chainList = require("@subwallet/chain-list");
+var _web = require("@subwallet/extension-base/koni/api/contract-handler/evm/web3");
+var _utils = require("@subwallet/extension-base/koni/api/contract-handler/utils");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils3 = require("@subwallet/extension-base/services/fee-service/utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+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'
+};
+exports.POLYGON_PROOF_INDEXER = POLYGON_PROOF_INDEXER;
+const POLYGON_GAS_INDEXER = {
+  MAINNET: 'https://gasstation.polygon.technology/zkevm',
+  TESTNET: 'https://gasstation.polygon.technology/zkevm/cardona'
+};
+exports.POLYGON_GAS_INDEXER = POLYGON_GAS_INDEXER;
+async function createPolygonBridgeTransaction(tokenInfo, originChainInfo, sender, recipientAddress, value, destinationNetwork, evmApi) {
+  var _priority$maxFeePerGa, _priority$maxPriority;
+  const polygonBridgeContractAddress = (0, _utils.getPolygonBridgeContract)(originChainInfo.slug);
+  const polygonBridgeContract = (0, _web.getWeb3Contract)(polygonBridgeContractAddress, evmApi, _utils._POLYGON_BRIDGE_ABI);
+  const tokenContract = (0, _utils2._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 (0, _utils3.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;
+}
+async function _createPolygonBridgeL1toL2Extrinsic(tokenInfo, originChainInfo, sender, recipientAddress, value, evmApi) {
+  return createPolygonBridgeTransaction(tokenInfo, originChainInfo, sender, recipientAddress, value, 1, evmApi);
+}
+async function _createPolygonBridgeL2toL1Extrinsic(tokenInfo, originChainInfo, sender, recipientAddress, value, evmApi) {
+  return createPolygonBridgeTransaction(tokenInfo, originChainInfo, sender, recipientAddress, value, 0, evmApi);
+}
+async function getClaimPolygonBridge(chainSlug, notification, evmApi) {
+  var _priority$maxFeePerGa2, _priority$maxPriority2;
+  const polygonBridgeContractAddress = (0, _utils.getPolygonBridgeContract)(chainSlug);
+  const polygonBridgeContract = (0, _web.getWeb3Contract)(polygonBridgeContractAddress, evmApi, _utils._POLYGON_BRIDGE_ABI);
+  const metadata = notification.metadata;
+  const isTestnet = chainSlug === _chainList.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 (0, _utils3.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;
+}
+async function isClaimedPolygonBridge(chainSlug, counter, sourceNetwork, evmApi) {
+  const polygonBridgeContractAddress = (0, _utils.getPolygonBridgeContract)(chainSlug);
+  const polygonBridgeContract = (0, _web.getWeb3Contract)(polygonBridgeContractAddress, evmApi, _utils._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();
+}
+function _isPolygonChainBridge(srcChain, destChain) {
+  if (srcChain === 'polygonzkEvm_cardona' && destChain === _chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA) {
+    return true;
+  } else if (srcChain === _chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA && destChain === 'polygonzkEvm_cardona') {
+    return true;
+  } else if (srcChain === 'polygonZkEvm' && destChain === _chainList.COMMON_CHAIN_SLUGS.ETHEREUM) {
+    return true;
+  } else if (srcChain === _chainList.COMMON_CHAIN_SLUGS.ETHEREUM && destChain === 'polygonZkEvm') {
+    return true;
+  }
+  return false;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LATEST_CHAIN_PATCH_FETCHING_INTERVAL = void 0;
+exports.md5HashChainAsset = md5HashChainAsset;
+exports.md5HashChainInfo = md5HashChainInfo;
+var _tsMd = require("ts-md5");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const LATEST_CHAIN_PATCH_FETCHING_INTERVAL = 180000;
+exports.LATEST_CHAIN_PATCH_FETCHING_INTERVAL = LATEST_CHAIN_PATCH_FETCHING_INTERVAL;
+function md5HashChainInfo(data) {
+  // todo: use from chain list package later
+  const {
+    chainStatus,
+    icon,
+    providers,
+    ...chainBaseInfo
+  } = data;
+  return _tsMd.Md5.hashStr(JSON.stringify(chainBaseInfo));
+}
+function md5HashChainAsset(data) {
+  // todo: use from chain list package later
+  const {
+    icon,
+    ...assetBaseInfo
+  } = data;
+  return _tsMd.Md5.hashStr(JSON.stringify(assetBaseInfo));
+}

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/constants.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports._ZK_ASSET_PREFIX = exports._XCM_TYPE = exports._XCM_CHAIN_GROUP = exports._TRANSFER_NOT_SUPPORTED_CHAINS = exports._TRANSFER_CHAIN_GROUP = exports._SUBSTRATE_DEFAULT_INFLATION_PARAMS = exports._STAKING_ERA_LENGTH_MAP = exports._PURE_EVM_CHAINS = exports._PREDEFINED_SINGLE_MODES = exports._PARACHAIN_INFLATION_DISTRIBUTION = exports._NFT_CHAIN_GROUP = exports._MULTI_CHAIN_ASSET_SRC = exports._MANTA_ZK_CHAIN_GROUP = exports._KNOWN_CHAIN_INFLATION_PARAMS = exports._EXPECTED_BLOCK_TIME = exports._DEFAULT_MANTA_ZK_CHAIN = exports._DEFAULT_ACTIVE_CHAINS = exports._CHAIN_LOGO_MAP_SRC = exports._CHAIN_INFO_SRC = exports._CHAIN_ASSET_SRC = exports._BALANCE_TOKEN_GROUP = exports._BALANCE_PARSING_CHAIN_GROUP = exports._BALANCE_CHAIN_GROUP = exports._ASSET_REF_SRC = exports._ASSET_LOGO_MAP_SRC = exports._API_OPTIONS_CHAIN_GROUP = exports.LATEST_CHAIN_DATA_FETCHING_INTERVAL = exports.EVM_REFORMAT_DECIMALS = exports.EVM_PASS_CONNECT_STATUS = exports.API_MAX_RETRY = exports.API_CONNECT_TIMEOUT = exports.API_AUTO_CONNECT_MS = void 0;
+exports._ZK_ASSET_PREFIX = exports._XCM_TYPE = exports._XCM_CHAIN_GROUP = exports._TRANSFER_NOT_SUPPORTED_CHAINS = exports._TRANSFER_CHAIN_GROUP = exports._SUBSTRATE_DEFAULT_INFLATION_PARAMS = exports._STAKING_ERA_LENGTH_MAP = exports._PURE_EVM_CHAINS = exports._PREDEFINED_SINGLE_MODES = exports._PARACHAIN_INFLATION_DISTRIBUTION = exports._NFT_CHAIN_GROUP = exports._MULTI_CHAIN_ASSET_SRC = exports._MANTA_ZK_CHAIN_GROUP = exports._KNOWN_CHAIN_INFLATION_PARAMS = exports._EXPECTED_BLOCK_TIME = exports._DEFAULT_MANTA_ZK_CHAIN = exports._DEFAULT_ACTIVE_CHAINS = exports._CHAIN_LOGO_MAP_SRC = exports._CHAIN_INFO_SRC = exports._CHAIN_ASSET_SRC = exports._BALANCE_TOKEN_GROUP = exports._BALANCE_PARSING_CHAIN_GROUP = exports._BALANCE_CHAIN_GROUP = exports._ASSET_REF_SRC = exports._ASSET_LOGO_MAP_SRC = exports._API_OPTIONS_CHAIN_GROUP = exports.SUFFICIENT_CHAIN = exports.LATEST_CHAIN_DATA_FETCHING_INTERVAL = exports.EVM_REFORMAT_DECIMALS = exports.EVM_PASS_CONNECT_STATUS = exports.API_MAX_RETRY = exports.API_CONNECT_TIMEOUT = exports.API_AUTO_CONNECT_MS = void 0;
 var _chainList = require("@subwallet/chain-list");
 var _types = require("@subwallet/chain-list/types");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
@@ -292,6 +292,8 @@ const _XCM_CHAIN_GROUP = {
   // default is xTokens pallet
 };
 exports._XCM_CHAIN_GROUP = _XCM_CHAIN_GROUP;
+const SUFFICIENT_CHAIN = ['astar', 'calamari', 'parallel', 'darwinia2', 'crabParachain', 'pangolin', 'statemint', 'moonriver', 'shiden', 'moonbeam', 'statemine', 'liberland', 'dentnet', 'phala', 'crust', 'dbcchain', 'rococo_assethub'];
+exports.SUFFICIENT_CHAIN = SUFFICIENT_CHAIN;
 const _XCM_TYPE = {
   RP: `${_types._SubstrateChainType.RELAYCHAIN}-${_types._SubstrateChainType.PARACHAIN}`,
   // DMP