@subwallet/extension-base 1.3.6-1 → 1.3.8-0

package/cjs/koni/background/handlers/Extension.js

@@ -33,6 +33,7 @@ var _token = require("@subwallet/extension-base/services/balance-service/transfe
 var _tonTransfer = require("@subwallet/extension-base/services/balance-service/transfer/ton-transfer");
 var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
 var _availBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge");
+var _polygonBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge");
 var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
 var _types2 = require("@subwallet/extension-base/services/chain-service/types");
 var _utils4 = require("@subwallet/extension-base/services/chain-service/utils");
@@ -1295,6 +1296,7 @@ class KoniExtension {
     const isAvailBridgeFromEvm = (0, _utils4._isPureEvmChain)(chainInfoMap[originNetworkKey]) && (0, _availBridge.isAvailChainBridge)(destinationNetworkKey);
     const isAvailBridgeFromAvail = (0, _availBridge.isAvailChainBridge)(originNetworkKey) && (0, _utils4._isPureEvmChain)(chainInfoMap[destinationNetworkKey]);
     const isSnowBridgeEvmTransfer = (0, _utils4._isPureEvmChain)(chainInfoMap[originNetworkKey]) && (0, _xcmParser._isSnowBridgeXcm)(chainInfoMap[originNetworkKey], chainInfoMap[destinationNetworkKey]) && !isAvailBridgeFromEvm;
+    const isPolygonBridgeTransfer = (0, _polygonBridge._isPolygonChainBridge)(originNetworkKey, destinationNetworkKey);
     let additionalValidator;
     let eventsHandler;
     if (fromKeyPair && destinationTokenInfo) {
@@ -1311,7 +1313,9 @@ class KoniExtension {
         evmApi
       };
       let funcCreateExtrinsic;
-      if (isSnowBridgeEvmTransfer) {
+      if (isPolygonBridgeTransfer) {
+        funcCreateExtrinsic = _xcm.createPolygonBridgeExtrinsic;
+      } else if (isSnowBridgeEvmTransfer) {
         funcCreateExtrinsic = _xcm.createSnowBridgeExtrinsic;
       } else if (isAvailBridgeFromEvm) {
         funcCreateExtrinsic = _xcm.createAvailBridgeTxFromEth;
@@ -1376,7 +1380,7 @@ class KoniExtension {
       transaction: extrinsic,
       data: inputData,
       extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
-      chainType: !isSnowBridgeEvmTransfer && !isAvailBridgeFromEvm ? _KoniTypes.ChainType.SUBSTRATE : _KoniTypes.ChainType.EVM,
+      chainType: !isSnowBridgeEvmTransfer && !isAvailBridgeFromEvm && !isPolygonBridgeTransfer ? _KoniTypes.ChainType.SUBSTRATE : _KoniTypes.ChainType.EVM,
       transferNativeAmount: (0, _utils4._isNativeToken)(originTokenInfo) ? value : '0',
       ignoreWarnings,
       isTransferAll: transferAll,
@@ -2578,7 +2582,6 @@ class KoniExtension {
   }
 
   // Phishing detect
-
   async passPhishingPage(_ref46) {
     let {
       url
@@ -2586,6 +2589,20 @@ class KoniExtension {
     return await this.#koniState.approvePassPhishingPage(url);
   }
 
+  // Set environment config
+  saveAppConfig(request) {
+    this.#koniState.saveEnvConfig('appConfig', request.appConfig);
+    return true;
+  }
+  saveBrowserConfig(request) {
+    this.#koniState.saveEnvConfig('browserConfig', request.browserConfig);
+    return true;
+  }
+  saveOSConfig(request) {
+    this.#koniState.saveEnvConfig('osConfig', request.osConfig);
+    return true;
+  }
+
   /// Wallet connect
 
   // Connect
@@ -3439,7 +3456,7 @@ class KoniExtension {
       chain,
       notification
     } = data;
-    const extrinsicType = _KoniTypes.ExtrinsicType.CLAIM_AVAIL_BRIDGE;
+    const extrinsicType = _KoniTypes.ExtrinsicType.CLAIM_BRIDGE;
     let transaction = null;
     let chainType;
     if ((0, _keyring.isSubstrateAddress)(address)) {
@@ -3460,6 +3477,32 @@ class KoniExtension {
       chainType
     });
   }
+  async getIsClaimedPolygonBridge(data) {
+    const evmApi = this.#koniState.getEvmApi(data.chainslug);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const isClaimed = await (0, _polygonBridge.isClaimedPolygonBridge)(data.chainslug, data.counter, data.sourceNetwork, evmApi);
+    return isClaimed;
+  }
+  async submitClaimPolygonBridge(data) {
+    const {
+      address,
+      chain,
+      notification
+    } = data;
+    const extrinsicType = _KoniTypes.ExtrinsicType.CLAIM_BRIDGE;
+    let transaction = null;
+    const evmApi = this.#koniState.getEvmApi(chain);
+    transaction = await (0, _polygonBridge.getClaimPolygonBridge)(chain, notification, evmApi);
+    const chainType = _KoniTypes.ChainType.EVM;
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain,
+      transaction,
+      data,
+      extrinsicType,
+      chainType
+    });
+  }
 
   /* Ledger */
 
@@ -3875,6 +3918,14 @@ class KoniExtension {
       case 'pri(phishing.pass)':
         return await this.passPhishingPage(request);
 
+      // Set Environment config
+      case 'pri(settings.saveAppConfig)':
+        return this.saveAppConfig(request);
+      case 'pri(settings.saveBrowserConfig)':
+        return this.saveBrowserConfig(request);
+      case 'pri(settings.saveOSConfig)':
+        return this.saveOSConfig(request);
+
       /// Keyring state
       case 'pri(keyring.subscribe)':
         return this.keyringStateSubscribe(id, port);
@@ -4039,6 +4090,8 @@ class KoniExtension {
         return this.fetchInappNotifications(request);
       case 'pri(inappNotification.get)':
         return this.getInappNotification(request);
+      case 'pri(inappNotification.isClaimedPolygonBridge)':
+        return this.getIsClaimedPolygonBridge(request);
       /* Notification service */
 
       /* Avail Bridge */
@@ -4046,6 +4099,13 @@ class KoniExtension {
         return this.submitClaimAvailBridge(request);
       /* Avail Bridge */
 
+      /* Polygon Bridge */
+
+      case 'pri(polygonBridge.submitClaimPolygonBridge)':
+        return this.submitClaimPolygonBridge(request);
+
+      /* Polygon Bridge */
+
       /* Ledger */
       case 'pri(ledger.generic.allow)':
         return this.subscribeLedgerGenericAllowChains(id, port);

package/cjs/koni/background/handlers/State.js

@@ -15,6 +15,7 @@ var _balanceService = require("@subwallet/extension-base/services/balance-servic
 var _types = require("@subwallet/extension-base/services/base/types");
 var _buyService = _interopRequireDefault(require("@subwallet/extension-base/services/buy-service"));
 var _campaignService = _interopRequireDefault(require("@subwallet/extension-base/services/campaign-service"));
+var _chainOnlineService = require("@subwallet/extension-base/services/chain-online-service");
 var _chainService = require("@subwallet/extension-base/services/chain-service");
 var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
@@ -112,6 +113,7 @@ class KoniState {
     this.feeService = new _service2.default(this);
     this.swapService = new _swapService.SwapService(this);
     this.inappNotificationService = new _inappNotificationService.InappNotificationService(this.dbService, this.keyringService, this.eventService, this.chainService);
+    this.chainOnlineService = new _chainOnlineService.ChainOnlineService(this.chainService, this.settingService, this.eventService, this.dbService);
     this.subscription = new _subscription.KoniSubscription(this, this.dbService);
     this.cron = new _cron.KoniCron(this, this.subscription, this.dbService);
     this.logger = (0, _util.logger)('State');
@@ -206,7 +208,6 @@ class KoniState {
   async init() {
     await this.eventService.waitCryptoReady;
     await this.chainService.init();
-    this.afterChainServiceInit();
     await this.migrationService.run();
     this.campaignService.init();
     this.mktCampaignService.init();
@@ -222,7 +223,11 @@ class KoniState {
     // TODO: consider moving this to a separate service
     await this.dbService.stores.crowdloan.removeEndedCrowdloans();
     await this.startSubscription();
+    this.chainOnlineService.checkLatestData();
     this.chainService.checkLatestData();
+    this.chainService.subscribeChainInfoMap().subscribe(() => {
+      this.afterChainServiceInit();
+    });
   }
   async initMantaPay(password) {
     var _this$chainService, _this$chainService$ma;
@@ -792,6 +797,7 @@ class KoniState {
     return this.chainService.stopAllChainApis();
   }
   async resumeAllNetworks() {
+    this.chainOnlineService.checkLatestData();
     return this.chainService.resumeAllChainApis();
   }
   publishCrowdloan(reset) {
@@ -1322,6 +1328,18 @@ class KoniState {
       });
     });
   }
+  saveEnvConfig(key, value) {
+    this.settingService.getEnvironmentList(config => {
+      const newSettings = {
+        ...config,
+        [key]: value
+      };
+      this.settingService.setEnvironment(newSettings);
+    });
+  }
+  initEnvConfig(envConfig) {
+    this.settingService.setEnvironment(envConfig);
+  }
   async resetWallet(resetAll) {
     await this.keyringService.resetWallet(resetAll);
     await this.earningService.resetYieldPosition();
@@ -1339,8 +1357,11 @@ class KoniState {
     this.chainService.resetWallet(resetAll);
     await this.walletConnectService.resetWallet(resetAll);
     await this.chainService.init();
-    this.afterChainServiceInit();
+    this.chainOnlineService.checkLatestData();
     this.chainService.checkLatestData();
+    this.chainService.subscribeChainInfoMap().subscribe(() => {
+      this.afterChainServiceInit();
+    });
   }
   async enableMantaPay(updateStore, address, password, seedPhrase) {
     var _this$chainService3, _this$chainService3$m, _this$chainService4, _this$chainService4$m, _this$chainService4$m2, _this$chainService11, _this$chainService11$, _this$chainService11$2;

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.6-1'
+  version: '1.3.8-0'
 };
 exports.packageInfo = packageInfo;

package/cjs/services/balance-service/helpers/subscribe/substrate/index.js

@@ -202,11 +202,12 @@ const subscribeForeignAssetBalance = async _ref2 => {
   const unsubList = await Promise.all(Object.values(tokenMap).map(tokenInfo => {
     try {
       if ((0, _utils2._isBridgedToken)(tokenInfo)) {
+        const version = ['statemint', 'statemine'].includes(chainInfo.slug) ? 4 : 3;
         const params = [{
           section: 'query',
           module: foreignAssetsAccountKey.split('_')[1],
           method: foreignAssetsAccountKey.split('_')[2],
-          args: addresses.map(address => [(0, _utils2._getTokenOnChainInfo)(tokenInfo) || (0, _xcmParser._adaptX1Interior)((0, _utils2._getXcmAssetMultilocation)(tokenInfo), 3), address])
+          args: addresses.map(address => [(0, _utils2._getTokenOnChainInfo)(tokenInfo) || (0, _xcmParser._adaptX1Interior)((0, _utils2._getXcmAssetMultilocation)(tokenInfo), version), address])
         }];
         return substrateApi.subscribeDataWithMulti(params, rs => {
           const balances = rs[foreignAssetsAccountKey];

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

@@ -66,7 +66,8 @@ const _NFT_CHAIN_GROUP = {
   vara: ['vara_network'],
   avail: ['avail_mainnet'],
   ternoa: ['ternoa', 'ternoa_alphanet'],
-  rari: ['rari']
+  rari: ['rari'],
+  story_odyssey: ['storyOdyssey', 'storyOdyssey_testnet']
 };
 
 // Staking--------------------------------------------------------------------------------------------------------------