@subwallet/extension-base 1.1.39-0 → 1.1.39-beta.0

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

@@ -38,6 +38,7 @@ class ChainService {
   // TODO: consider BehaviorSubject
   chainInfoMapSubject = new _rxjs.Subject();
   chainStateMapSubject = new _rxjs.Subject();
+  chainStatusMapSubject = new _rxjs.BehaviorSubject({});
   assetRegistrySubject = new _rxjs.Subject();
   multiChainAssetMapSubject = new _rxjs.Subject();
   xcmRefMapSubject = new _rxjs.Subject();
@@ -111,6 +112,9 @@ class ChainService {
   subscribeChainStateMap() {
     return this.chainStateMapSubject;
   }
+  subscribeChainStatusMap() {
+    return this.chainStatusMapSubject;
+  }
   getAssetRegistry() {
     return this.dataMap.assetRegistry;
   }
@@ -188,6 +192,12 @@ class ChainService {
   getChainStateByKey(key) {
     return this.dataMap.chainStateMap[key];
   }
+  getChainStatusMap() {
+    return this.chainStatusMapSubject.getValue();
+  }
+  getChainStatusByKey(key) {
+    return this.getChainStatusMap()[key];
+  }
   getActiveChains() {
     return Object.entries(this.dataMap.chainStateMap).filter(_ref => {
       let [, chainState] = _ref;
@@ -353,9 +363,32 @@ class ChainService {
     this.lockChainInfoMap = false;
     return true;
   }
-  setChainConnectionStatus(slug, connectionStatus) {
-    const chainStateMap = this.getChainStateMap();
-    chainStateMap[slug].connectionStatus = connectionStatus;
+  connectionStatusQueueMap = {};
+  updateChainConnectionStatus(slug, connectionStatus) {
+    this.connectionStatusQueueMap[slug] = connectionStatus;
+    (0, _utils2.addLazy)('updateChainConnectionStatus', () => {
+      const chainStatusMap = this.getChainStatusMap();
+      let update = false;
+      Object.entries(this.connectionStatusQueueMap).forEach(_ref3 => {
+        let [slug, status] = _ref3;
+        if (chainStatusMap[slug]) {
+          if (chainStatusMap[slug].connectionStatus !== status) {
+            chainStatusMap[slug].connectionStatus = status;
+            chainStatusMap[slug].lastUpdated = Date.now();
+            update = true;
+          }
+        } else {
+          chainStatusMap[slug] = {
+            slug,
+            connectionStatus: status,
+            lastUpdated: Date.now()
+          };
+          update = true;
+        }
+      });
+      this.connectionStatusQueueMap = {};
+      update && this.chainStatusMapSubject.next(chainStatusMap);
+    });
   }
   upsertCustomToken(token) {
     if (token.slug.length === 0) {
@@ -484,8 +517,8 @@ class ChainService {
     this.logger.log('Finished updating latest asset ref');
   }
   handleLatestPriceId(latestPriceIds) {
-    Object.entries(latestPriceIds).forEach(_ref3 => {
-      let [slug, priceId] = _ref3;
+    Object.entries(latestPriceIds).forEach(_ref4 => {
+      let [slug, priceId] = _ref4;
       if (this.dataMap.assetRegistry[slug]) {
         this.dataMap.assetRegistry[slug].priceId = priceId;
       }
@@ -510,12 +543,12 @@ class ChainService {
   async initApis() {
     const chainInfoMap = this.getChainInfoMap();
     const chainStateMap = this.getChainStateMap();
-    await Promise.all(Object.entries(chainInfoMap).filter(_ref4 => {
+    await Promise.all(Object.entries(chainInfoMap).filter(_ref5 => {
       var _chainStateMap$slug;
-      let [slug] = _ref4;
+      let [slug] = _ref5;
       return (_chainStateMap$slug = chainStateMap[slug]) === null || _chainStateMap$slug === void 0 ? void 0 : _chainStateMap$slug.active;
-    }).map(_ref5 => {
-      let [, chainInfo] = _ref5;
+    }).map(_ref6 => {
+      let [, chainInfo] = _ref6;
       try {
         return this.initApiForChain(chainInfo);
       } catch (e) {
@@ -530,13 +563,8 @@ class ChainService {
       providerName
     } = this.getChainCurrentProviderByKey(chainInfo.slug);
     const onUpdateStatus = status => {
-      const currentStatus = this.getChainStateByKey(chainInfo.slug).connectionStatus;
-
-      // Avoid unnecessary update in case disable chain
-      if (currentStatus !== status) {
-        this.setChainConnectionStatus(chainInfo.slug, status);
-        this.updateChainStateMapSubscription();
-      }
+      const slug = chainInfo.slug;
+      this.updateChainConnectionStatus(slug, status);
     };
     if (chainInfo.substrateInfo !== null && chainInfo.substrateInfo !== undefined) {
       if (_constants._MANTA_ZK_CHAIN_GROUP.includes(chainInfo.slug) && _utils2.MODULE_SUPPORT.MANTA_ZK && this.mantaChainHandler) {
@@ -635,7 +663,7 @@ class ChainService {
     this.lockChainInfoMap = true;
     chainStateMap[chainSlug].active = false;
     // Set disconnect state for inactive chain
-    chainStateMap[chainSlug].connectionStatus = _types3._ChainConnectionStatus.DISCONNECTED;
+    this.updateChainConnectionStatus(chainSlug, _types3._ChainConnectionStatus.DISCONNECTED);
     this.destroyApiForChain(chainInfo);
     this.dbService.updateChainStore({
       ...chainInfo,
@@ -728,9 +756,9 @@ class ChainService {
         this.dataMap.chainStateMap[chainInfo.slug] = {
           currentProvider: providerKey,
           slug: chainInfo.slug,
-          connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
           active: _constants._DEFAULT_ACTIVE_CHAINS.includes(chainInfo.slug)
         };
+        this.updateChainConnectionStatus(chainInfo.slug, _types3._ChainConnectionStatus.DISCONNECTED);
 
         // create data for storage
         newStorageData.push({
@@ -781,9 +809,9 @@ class ChainService {
           this.dataMap.chainStateMap[storedSlug] = {
             currentProvider: selectedProvider,
             slug: storedSlug,
-            connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
             active: canActive && storedChainInfo.active
           };
+          this.updateChainConnectionStatus(storedSlug, _types3._ChainConnectionStatus.DISCONNECTED);
           newStorageData.push({
             ...mergedChainInfoMap[storedSlug],
             active: canActive && storedChainInfo.active,
@@ -803,9 +831,9 @@ class ChainService {
             this.dataMap.chainStateMap[duplicatedDefaultSlug] = {
               currentProvider: storedChainInfo.currentProvider,
               slug: duplicatedDefaultSlug,
-              connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
               active: storedChainInfo.active
             };
+            this.updateChainConnectionStatus(duplicatedDefaultSlug, _types3._ChainConnectionStatus.DISCONNECTED);
             newStorageData.push({
               ...mergedChainInfoMap[duplicatedDefaultSlug],
               active: storedChainInfo.active,
@@ -830,9 +858,9 @@ class ChainService {
               currentProvider: storedChainInfo.currentProvider,
               // TODO: review
               slug: storedSlug,
-              connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
               active: storedChainInfo.active
             };
+            this.updateChainConnectionStatus(storedSlug, _types3._ChainConnectionStatus.DISCONNECTED);
             newStorageData.push({
               ...mergedChainInfoMap[storedSlug],
               active: storedChainInfo.active,
@@ -845,15 +873,15 @@ class ChainService {
       }
 
       // Fill in the missing chainState and storageData (new chains never before seen)
-      Object.entries(mergedChainInfoMap).forEach(_ref6 => {
-        let [slug, chainInfo] = _ref6;
+      Object.entries(mergedChainInfoMap).forEach(_ref7 => {
+        let [slug, chainInfo] = _ref7;
         if (!(slug in this.dataMap.chainStateMap)) {
           this.dataMap.chainStateMap[slug] = {
             currentProvider: Object.keys(chainInfo.providers)[0],
             slug,
-            connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
             active: _constants._DEFAULT_ACTIVE_CHAINS.includes(slug)
           };
+          this.updateChainConnectionStatus(slug, _types3._ChainConnectionStatus.DISCONNECTED);
           newStorageData.push({
             ...mergedChainInfoMap[slug],
             active: _constants._DEFAULT_ACTIVE_CHAINS.includes(slug),
@@ -928,9 +956,7 @@ class ChainService {
     }
   }
   updateChainStateMapSubscription() {
-    (0, _utils2.addLazy)('updateChainStateMapSubscription', () => {
-      this.chainStateMapSubject.next(this.getChainStateMap());
-    }, 300, 900);
+    this.chainStateMapSubject.next(this.getChainStateMap());
   }
   updateChainInfoMapSubscription() {
     this.chainInfoMapSubject.next(this.getChainInfoMap());
@@ -1039,10 +1065,17 @@ class ChainService {
     const chainStateMap = this.getChainStateMap();
     chainStateMap[newChainSlug] = {
       active: true,
-      connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
       currentProvider: params.chainEditInfo.currentProvider,
       slug: newChainSlug
     };
+
+    // const chainStatusMap = this.getChainStatusMap();
+    // const chainStatusMap[newChainSlug] = {
+    //   slug: newChainSlug,
+    //   connectionStatus: _ChainConnectionStatus.DISCONNECTED,
+    //   lastUpdated: Date.now()
+    // };
+
     await this.initApiForChain(chainInfo);
 
     // create a record in assetRegistry for native token and update store/subscription
@@ -1327,29 +1360,6 @@ class ChainService {
     await Promise.all([this.substrateChainHandler.wakeUp(), this.evmChainHandler.wakeUp()]);
     this.checkLatestData();
   }
-  checkAndUpdateStatusMapForChain(chainSlug) {
-    const substrateApiMap = this.getSubstrateApiMap();
-    const evmApiMap = this.getEvmApiMap();
-    const chainState = this.getChainStateByKey(chainSlug);
-    let update = false;
-    function updateState(current, status) {
-      if (current.connectionStatus !== status) {
-        current.connectionStatus = status;
-        update = true;
-      }
-    }
-    if (chainState.active) {
-      const api = substrateApiMap[chainSlug] || evmApiMap[chainSlug];
-      if (api) {
-        updateState(chainState, api.isApiConnected ? _types3._ChainConnectionStatus.CONNECTED : _types3._ChainConnectionStatus.DISCONNECTED);
-      }
-    } else {
-      updateState(chainState, _types3._ChainConnectionStatus.DISCONNECTED);
-    }
-    if (update) {
-      this.dataMap.chainStateMap[chainSlug] = chainState;
-    }
-  }
   async initAssetSettings() {
     const assetSettings = await this.getAssetSettings();
     const activeChainSlugs = this.getActiveChainSlugs();

package/cjs/services/migration-service/scripts/MigrateEthProvider.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _MigrateProvider = _interopRequireDefault(require("./MigrateProvider"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateEthProvider extends _MigrateProvider.default {
+  newProvider = 'ethereum';
+  oldProvider = 'Cloudflare';
+  slug = 'Llamarpc';
+}
+exports.default = MigrateEthProvider;

package/cjs/services/migration-service/scripts/MigratePioneerProvider.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _MigrateProvider = _interopRequireDefault(require("./MigrateProvider"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigratePioneerProvider extends _MigrateProvider.default {
+  slug = 'pioneer';
+  oldProvider = 'OnFinality';
+  newProvider = 'Pioneer';
+}
+exports.default = MigratePioneerProvider;

package/cjs/services/migration-service/scripts/MigrateProvider.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateProvider extends _Base.default {
+  async run() {
+    const state = this.state;
+    const chainState = state.getChainStateByKey(this.slug);
+    const chainInfo = state.getChainInfo(this.slug);
+    if (chainState && chainState.active && chainState.currentProvider === this.oldProvider) {
+      await state.upsertChainInfo({
+        mode: 'update',
+        chainEditInfo: {
+          currentProvider: this.newProvider,
+          slug: this.slug,
+          providers: chainInfo.providers
+        }
+      });
+    }
+  }
+}
+exports.default = MigrateProvider;

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

@@ -0,0 +1,241 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DatabaseService = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _databases = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/databases"));
+var _dbStores = require("@subwallet/extension-base/services/storage-service/db-stores");
+var _ChainStakingMetadata = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/ChainStakingMetadata"));
+var _NominatorMetadata = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata"));
+var _utils = require("@subwallet/extension-base/utils");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class DatabaseService {
+  // TODO: might remove this
+
+  constructor(eventService) {
+    this.eventService = eventService;
+    this.logger = (0, _util.logger)('DB-Service');
+    this._db = new _databases.default();
+    this._db.on('ready', () => {
+      this.eventService.emit('database.ready', true);
+    });
+    this.stores = {
+      price: new _dbStores.PriceStore(this._db.price),
+      balance: new _dbStores.BalanceStore(this._db.balances),
+      nft: new _dbStores.NftStore(this._db.nfts),
+      nftCollection: new _dbStores.NftCollectionStore(this._db.nftCollections),
+      crowdloan: new _dbStores.CrowdloanStore(this._db.crowdloans),
+      staking: new _dbStores.StakingStore(this._db.stakings),
+      transaction: new _dbStores.TransactionStore(this._db.transactions),
+      migration: new _dbStores.MigrationStore(this._db.migrations),
+      metadata: new _dbStores.MetadataStore(this._db.metadata),
+      chain: new _dbStores.ChainStore(this._db.chain),
+      asset: new _dbStores.AssetStore(this._db.asset),
+      // staking
+      chainStakingMetadata: new _ChainStakingMetadata.default(this._db.chainStakingMetadata),
+      nominatorMetadata: new _NominatorMetadata.default(this._db.nominatorMetadata)
+    };
+  }
+  async updatePriceStore(priceData) {
+    await this.stores.price.table.put(priceData);
+  }
+  async getPriceStore() {
+    try {
+      const rs = await this.stores.price.table.get('usd');
+      return rs;
+    } catch (e) {
+      this.logger.error(e);
+      return undefined;
+    }
+  }
+
+  // Balance
+  async getStoredBalance() {
+    return this.stores.balance.table.toArray();
+  }
+  async updateBalanceStore(address, item) {
+    if (item.state === _KoniTypes.APIItemState.READY) {
+      return this.stores.balance.upsert({
+        address,
+        ...item
+      });
+    }
+  }
+  async removeFromBalanceStore(assets) {
+    return this.stores.balance.removeBySlugs(assets);
+  }
+
+  // Crowdloan
+  async updateCrowdloanStore(chain, address, item) {
+    if (item.state === _KoniTypes.APIItemState.READY && item.contribute !== '0') {
+      return this.stores.crowdloan.upsert({
+        chain,
+        address,
+        ...item
+      });
+    } else {
+      return this.stores.crowdloan.deleteByChainAndAddress(chain, address);
+    }
+  }
+
+  // Staking
+  async updateStaking(chain, address, item) {
+    if (item.state === _KoniTypes.APIItemState.READY) {
+      return this.stores.staking.upsert(item);
+    }
+  }
+  async getStakings(addresses, chains) {
+    return this.stores.staking.getStakings(addresses, chains);
+  }
+  async getStakingsByChains(chains) {
+    return this.stores.staking.getStakingsByChains(chains);
+  }
+  async getPooledStakings(addresses, chainHashes) {
+    return this.stores.staking.getPooledStakings(addresses, chainHashes);
+  }
+  subscribeStaking(addresses, chainList, callback) {
+    this.stakingSubscription && this.stakingSubscription.unsubscribe();
+    this.stakingSubscription = this.stores.staking.subscribeStaking(addresses, chainList).subscribe({
+      next: stakings => callback && callback(stakings)
+    });
+    return this.stakingSubscription;
+  }
+  subscribeChainStakingMetadata(chains, callback) {
+    this.stores.chainStakingMetadata.subscribeByChain(chains).subscribe({
+      next: data => callback && callback(data)
+    });
+  }
+  subscribeNominatorMetadata(addresses, callback) {
+    return this.stores.nominatorMetadata.subscribeByAddresses(addresses).subscribe({
+      next: data => callback && callback(data)
+    });
+  }
+
+  // Transaction histories
+  async getHistories(query) {
+    return this.stores.transaction.queryHistory(query);
+  }
+  async upsertHistory(histories) {
+    const cleanedHistory = histories.filter(x => x && x.address && x.chain && x.extrinsicHash);
+    return this.stores.transaction.bulkUpsert(cleanedHistory);
+  }
+  async updateHistoryByExtrinsicHash(extrinsicHash, updateData) {
+    const canUpdate = updateData && extrinsicHash;
+    if (!canUpdate) {
+      return;
+    }
+    return this.stores.transaction.updateWithQuery({
+      extrinsicHash
+    }, updateData);
+  }
+
+  // NFT Collection
+  async addNftCollection(collection) {
+    return this.stores.nftCollection.upsert(collection);
+  }
+  async deleteNftCollection(chain, collectionId) {
+    await this.stores.nftCollection.removeCollection(chain, collectionId);
+    await this.stores.nft.deleteNftsByCollection(chain, collectionId);
+  }
+  getAllNftCollection(chainHashes) {
+    return this.stores.nftCollection.getNftCollection(chainHashes);
+  }
+
+  // NFT
+  subscribeNft(addresses, chainHashes, callback) {
+    this.nftSubscription && this.nftSubscription.unsubscribe();
+    this.nftSubscription = this.stores.nft.subscribeNft(addresses, chainHashes).subscribe({
+      next: nfts => callback && callback(nfts)
+    });
+    return this.nftSubscription;
+  }
+  async cleanUpNft(chain, owner, collectionIds, nftIds, ownNothing) {
+    if (ownNothing) {
+      return this.stores.nft.deleteNftsByChainAndOwner(chain, (0, _utils.reformatAddress)(owner, 42), collectionIds);
+    }
+    return this.stores.nft.cleanUpNfts(chain, (0, _utils.reformatAddress)(owner, 42), collectionIds, nftIds);
+  }
+  async getNft(addresses, chainHashes) {
+    return this.stores.nft.getNft(addresses, chainHashes);
+  }
+  async addNft(address, nft) {
+    return this.stores.nft.upsert({
+      ...nft,
+      address
+    });
+  }
+  handleNftTransfer(chain, addresses, nftItem) {
+    return this.stores.nft.deleteNftItem(chain, addresses, nftItem);
+  }
+  removeNfts(chain, address, collectionId, nftIds) {
+    return this.stores.nft.removeNfts(chain, address, collectionId, nftIds);
+  }
+
+  // Chain
+  async updateChainStore(item) {
+    return this.stores.chain.upsert(item);
+  }
+  async bulkUpdateChainStore(data) {
+    return this.stores.chain.bulkUpsert(data);
+  }
+  async removeFromChainStore(chains) {
+    return this.stores.chain.removeChains(chains);
+  }
+  async getAllChainStore() {
+    return this.stores.chain.getAll();
+  }
+
+  // Asset
+  async updateAssetStore(item) {
+    return this.stores.asset.upsert(item);
+  }
+  async getAllAssetStore() {
+    return this.stores.asset.getAll();
+  }
+  async removeFromAssetStore(items) {
+    return this.stores.asset.removeAssets(items);
+  }
+
+  // Staking
+  async updateChainStakingMetadata(item, changes) {
+    const existingRecord = await this.stores.chainStakingMetadata.getByChainAndType(item.chain, item.type);
+    if (existingRecord && changes) {
+      return this.stores.chainStakingMetadata.updateByChainAndType(item.chain, item.type, changes);
+    }
+    return this.stores.chainStakingMetadata.upsert(item);
+  }
+  async getChainStakingMetadata() {
+    return this.stores.chainStakingMetadata.getAll();
+  }
+  async getStakingMetadataByChain(chain) {
+    let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _KoniTypes.StakingType.NOMINATED;
+    return this.stores.chainStakingMetadata.getByChainAndType(chain, type);
+  }
+  async updateNominatorMetadata(item) {
+    return this.stores.nominatorMetadata.upsert(item);
+  }
+  async getNominatorMetadata() {
+    return this.stores.nominatorMetadata.getAll();
+  }
+  async resetWallet(resetAll) {
+    return new Promise((resolve, reject) => {
+      const stores = [this.stores.balance, this.stores.nft, this.stores.nftCollection, this.stores.crowdloan, this.stores.staking, this.stores.transaction, this.stores.nominatorMetadata];
+      if (resetAll) {
+        stores.push(this.stores.chain, this.stores.asset);
+      }
+      const promises = stores.map(store => store.clear());
+      Promise.all(promises).then(() => {
+        resolve();
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+}
+exports.DatabaseService = DatabaseService;

package/cjs/types.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/utils/address.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertSubjectInfoToAddresses = void 0;
+exports.quickFormatAddressToCompare = quickFormatAddressToCompare;
+exports.simpleAddress = void 0;
+var _index = require("@subwallet/extension-base/utils/index");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const simpleAddress = address => {
+  if ((0, _utilCrypto.isEthereumAddress)(address)) {
+    return address;
+  }
+  return (0, _utilCrypto.encodeAddress)((0, _utilCrypto.decodeAddress)(address));
+};
+exports.simpleAddress = simpleAddress;
+function quickFormatAddressToCompare(address) {
+  if (!(0, _utilCrypto.isAddress)(address)) {
+    return address;
+  }
+  return (0, _index.reformatAddress)(address, 42).toLowerCase();
+}
+const convertSubjectInfoToAddresses = subjectInfo => {
+  return Object.values(subjectInfo).map(info => ({
+    address: info.json.address,
+    type: info.type,
+    ...info.json.meta
+  }));
+};
+exports.convertSubjectInfoToAddresses = convertSubjectInfoToAddresses;

package/cjs/utils/keyring.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractPrivateKey = extractPrivateKey;
+exports.unlockAccount = exports.lockAccount = void 0;
+var _uiKeyring = require("@subwallet/ui-keyring");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// import _decode from '@polkadot/keyring/pair/decode';
+
+function extract(address) {
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+  const rs = this.getPair(address);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  console.log(rs.publicKey);
+}
+function extractPrivateKey(keyring, address, password) {
+  extract.call(keyring, address);
+}
+const unlockAccount = signAddress => {
+  let publicKey;
+  try {
+    publicKey = _uiKeyring.keyring.decodeAddress(signAddress);
+  } catch (error) {
+    console.error(error);
+    return 'Unable to decode address';
+  }
+  const pair = _uiKeyring.keyring.getPair(publicKey);
+  if (!pair) {
+    return 'Unable to find pair';
+  }
+  if (pair.isLocked) {
+    try {
+      _uiKeyring.keyring.unlockPair(pair.address);
+    } catch (e) {
+      return e.message;
+    }
+  }
+  return null;
+};
+exports.unlockAccount = unlockAccount;
+const lockAccount = address => {
+  try {
+    const pair = _uiKeyring.keyring.getPair(address);
+    if (pair) {
+      pair.lock();
+    }
+  } catch (error) {
+    console.error('Unable to lock account', error);
+  }
+};
+exports.lockAccount = lockAccount;

package/koni/background/handlers/Extension.d.ts

@@ -185,6 +185,7 @@ export default class KoniExtension {
     private getListDeriveAccounts;
     private subscribeChainInfoMap;
     private subscribeChainStateMap;
+    private subscribeChainStatusMap;
     private subscribeAssetRegistry;
     private subscribeMultiChainAssetMap;
     private subscribeXcmRefMap;

package/koni/background/handlers/Extension.js

@@ -3169,6 +3169,19 @@ export default class KoniExtension {
     });
     return this.#koniState.getChainStateMap();
   }
+  subscribeChainStatusMap(id, port) {
+    const cb = createSubscription(id, port);
+    const chainStateMapSubscription = this.#koniState.chainService.subscribeChainStatusMap().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, chainStateMapSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.chainService.getChainStatusMap();
+  }
   async subscribeAssetRegistry(id, port) {
     const cb = createSubscription(id, port);
     let ready = false;
@@ -3458,7 +3471,7 @@ export default class KoniExtension {
       });
       const {
         connectionStatus
-      } = this.#koniState.chainService.getChainStateByKey(_DEFAULT_MANTA_ZK_CHAIN);
+      } = this.#koniState.chainService.getChainStatusByKey(_DEFAULT_MANTA_ZK_CHAIN);
       if (connectionStatus !== _ChainConnectionStatus.CONNECTED) {
         // TODO: do better
         await timeout();
@@ -4194,6 +4207,8 @@ export default class KoniExtension {
         return this.subscribeChainInfoMap(id, port);
       case 'pri(chainService.subscribeChainStateMap)':
         return this.subscribeChainStateMap(id, port);
+      case 'pri(chainService.subscribeChainStatusMap)':
+        return this.subscribeChainStatusMap(id, port);
       case 'pri(chainService.subscribeXcmRefMap)':
         return this.subscribeXcmRefMap(id, port);
       case 'pri(chainService.getSupportedContractTypes)':