@subwallet/extension-base 1.0.13-0 → 1.1.1

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

@@ -44,6 +44,8 @@ var _subscription = require("../subscription");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+// eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment
+const passworder = require('browser-passworder');
 const ETH_DERIVE_DEFAULT = '/m/44\'/60\'/0\'/0/0';
 
 // List of providers passed into constructor. This is the list of providers
@@ -75,6 +77,8 @@ class KoniState {
   crowdloanMap = generateDefaultCrowdloanMap();
   crowdloanSubject = new _rxjs.Subject();
   nftSubject = new _rxjs.Subject();
+  mantaPayConfigSubject = new _rxjs.Subject();
+  isMantaPayEnabled = false;
   stakingSubject = new _rxjs.Subject();
   chainStakingMetadataSubject = new _rxjs.Subject();
   stakingNominatorMetadataSubject = new _rxjs.Subject();
@@ -217,11 +221,25 @@ class KoniState {
     this.onAccountRemove();
     await this.startSubscription();
   }
+  async initMantaPay(password) {
+    const mantaPayConfig = await this.chainService.mantaPay.getMantaPayFirstConfig(_constants2._DEFAULT_MANTA_ZK_CHAIN);
+    if (mantaPayConfig && mantaPayConfig.enabled && !this.isMantaPayEnabled) {
+      // only init the first login
+      console.debug('Initiating MantaPay for', mantaPayConfig.address);
+      await this.enableMantaPay(false, mantaPayConfig.address, password);
+      console.debug('Initiated MantaPay for', mantaPayConfig.address);
+      this.isMantaPayEnabled = true;
+      this.eventService.emit('mantaPay.enable', mantaPayConfig.address);
+    }
+  }
   async startSubscription() {
     await this.eventService.waitKeyringReady;
     this.dbService.subscribeChainStakingMetadata([], data => {
       this.chainStakingMetadataSubject.next(data);
     });
+    this.dbService.subscribeMantaPayConfig(_constants2._DEFAULT_MANTA_ZK_CHAIN, data => {
+      this.mantaPayConfigSubject.next(data);
+    });
     let unsub;
     this.keyringService.accountSubject.subscribe(accounts => {
       // TODO: improve this
@@ -297,6 +315,10 @@ class KoniState {
   async getNominatorMetadata() {
     return this.dbService.getNominatorMetadata();
   }
+  async getMantaPayConfig(chain) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return this.dbService.getMantaPayConfig(chain);
+  }
   async getStaking() {
     const addresses = this.getDecodedAddresses();
     const stakings = await this.dbService.getStakings(addresses, this.activeChainSlugs);
@@ -318,6 +340,9 @@ class KoniState {
   async getPooledStakingRecordsByAddress(addresses) {
     return this.dbService.getPooledStakings(addresses, this.activeChainSlugs);
   }
+  subscribeMantaPayConfig() {
+    return this.mantaPayConfigSubject;
+  }
   subscribeStaking() {
     return this.stakingSubject;
   }
@@ -891,8 +916,13 @@ class KoniState {
     return result;
   };
   async disableChain(chainSlug) {
-    // const defaultChains = this.getDefaultNetworkKeys();
     await this.chainService.updateAssetSettingByChain(chainSlug, false);
+    if (_constants2._MANTA_ZK_CHAIN_GROUP.includes(chainSlug)) {
+      const mantaPayConfig = await this.chainService.mantaPay.getMantaPayFirstConfig(_constants2._DEFAULT_MANTA_ZK_CHAIN);
+      if (mantaPayConfig && mantaPayConfig.enabled && this.isMantaPayEnabled) {
+        await this.disableMantaPay(mantaPayConfig.address);
+      }
+    }
     return this.chainService.disableChain(chainSlug);
   }
   async enableChain(chainSlug) {
@@ -1327,50 +1357,51 @@ class KoniState {
     return await this.requestService.completeConfirmation(request);
   }
   onInstall() {
-    const singleModes = Object.values(_constants2._PREDEFINED_SINGLE_MODES);
-    try {
-      // Open expand page
-      const url = `${chrome.extension.getURL('index.html')}#/`;
-      (0, _helpers.withErrorLog)(() => chrome.tabs.create({
-        url
-      }));
-    } catch (e) {
-      console.error(e);
-    }
-    const setUpSingleMode = _ref12 => {
-      let {
-        networkKeys,
-        theme
-      } = _ref12;
-      networkKeys.forEach(key => {
-        this.enableChain(key).catch(console.error);
-      });
-      const chainInfo = this.chainService.getChainInfoByKey(networkKeys[0]);
-      const genesisHash = (0, _utils._getSubstrateGenesisHash)(chainInfo);
-      this.setCurrentAccount({
-        address: _constants.ALL_ACCOUNT_KEY,
-        currentGenesisHash: genesisHash.length > 0 ? genesisHash : null
-      });
-      this.setTheme(theme);
-    };
-    chrome.tabs.query({}, function (tabs) {
-      const openingUrls = tabs.map(t => t.url);
-      const singleMode = singleModes.find(_ref13 => {
-        let {
-          autoTriggerDomain
-        } = _ref13;
-        const urlRegex = new RegExp(autoTriggerDomain);
-        return Boolean(openingUrls.find(url => {
-          return url && urlRegex.test(url);
-        }));
-      });
-      if (singleMode) {
-        // Wait for everything is ready before enable single mode
-        setTimeout(() => {
-          setUpSingleMode(singleMode);
-        }, 999);
-      }
-    });
+    // const singleModes = Object.values(_PREDEFINED_SINGLE_MODES);
+
+    // This logic is moved to installation.ts
+    // try {
+    //   // Open expand page
+    //   const url = `${chrome.extension.getURL('index.html')}#/`;
+    //
+    //   withErrorLog(() => chrome.tabs.create({ url }));
+    // } catch (e) {
+    //   console.error(e);
+    // }
+
+    // const setUpSingleMode = ({ networkKeys, theme }: SingleModeJson) => {
+    //   networkKeys.forEach((key) => {
+    //     this.enableChain(key).catch(console.error);
+    //   });
+    //
+    //   const chainInfo = this.chainService.getChainInfoByKey(networkKeys[0]);
+    //   const genesisHash = _getSubstrateGenesisHash(chainInfo);
+    //
+    //   this.setCurrentAccount({
+    //     address: ALL_ACCOUNT_KEY,
+    //     currentGenesisHash: genesisHash.length > 0 ? genesisHash : null
+    //   });
+    //   this.setTheme(theme);
+    // };
+    //
+    // chrome.tabs.query({}, function (tabs) {
+    //   const openingUrls = tabs.map((t) => t.url);
+    //
+    //   const singleMode = singleModes.find(({ autoTriggerDomain }) => {
+    //     const urlRegex = new RegExp(autoTriggerDomain);
+    //
+    //     return Boolean(openingUrls.find((url) => {
+    //       return url && urlRegex.test(url);
+    //     }));
+    //   });
+    //
+    //   if (singleMode) {
+    //     // Wait for everything is ready before enable single mode
+    //     setTimeout(() => {
+    //       setUpSingleMode(singleMode);
+    //     }, 999);
+    //   }
+    // });
   }
   get activeNetworks() {
     return this.chainService.getActiveChainInfos();
@@ -1458,9 +1489,6 @@ class KoniState {
   createUnsubscriptionHandle(id, unsubscribe) {
     this.unsubscriptionMap[id] = unsubscribe;
   }
-  updateChainConnectionStatus(chain, status) {
-    this.chainService.setChainConnectionStatus(chain, status);
-  }
   async autoEnableChains(addresses) {
     const assetMap = this.chainService.getAssetRegistry();
     const promiseList = addresses.map(address => {
@@ -1475,7 +1503,7 @@ class KoniState {
     const chainMap = this.chainService.getChainInfoMap();
     const balanceDataList = await Promise.all(promiseList);
     balanceDataList.forEach(balanceData => {
-      balanceData && balanceData.forEach(_ref14 => {
+      balanceData && balanceData.forEach(_ref12 => {
         var _currentAssetSettings;
         let {
           balance,
@@ -1484,7 +1512,7 @@ class KoniState {
           locked,
           network,
           symbol
-        } = _ref14;
+        } = _ref12;
         const chain = _subscanChainMap.SUBSCAN_CHAIN_MAP_REVERSE[network];
         const chainInfo = chain ? chainMap[chain] : null;
         const balanceIsEmpty = (!balance || balance === '0') && (!locked || locked === '0') && (!bonded || bonded === '0');
@@ -1567,5 +1595,149 @@ class KoniState {
     await this.walletConnectService.resetWallet(resetAll);
     await this.chainService.init();
   }
+  async enableMantaPay(updateStore, address, password, seedPhrase) {
+    var _this$chainService$ma, _this$chainService$ma6;
+    if (!address || (0, _utilCrypto.isEthereumAddress)(address)) {
+      return;
+    }
+    this.chainService.mantaPay.setCurrentAddress(address);
+    await ((_this$chainService$ma = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma === void 0 ? void 0 : _this$chainService$ma.initialSigner());
+    if (updateStore && seedPhrase) {
+      var _this$chainService$ma2, _this$chainService$ma3, _this$chainService$ma4;
+      // first time initiation
+      await ((_this$chainService$ma2 = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma2 === void 0 ? void 0 : _this$chainService$ma2.loadUserSeedPhrase(seedPhrase));
+      const authContext = await ((_this$chainService$ma3 = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma3 === void 0 ? void 0 : _this$chainService$ma3.getAuthorizationContext());
+      await ((_this$chainService$ma4 = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma4 === void 0 ? void 0 : _this$chainService$ma4.loadAuthorizationContext(authContext));
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+      const encryptedData = await passworder.encrypt(password, authContext);
+      await this.chainService.mantaPay.saveMantaAuthContext({
+        chain: _constants2._DEFAULT_MANTA_ZK_CHAIN,
+        address,
+        data: encryptedData
+      });
+    } else {
+      var _this$chainService$ma5;
+      const authContext = await this.chainService.mantaPay.getMantaAuthContext(address, _constants2._DEFAULT_MANTA_ZK_CHAIN);
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+      const decryptedData = await passworder.decrypt(password, authContext.data);
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
+      const proofAuthKey = new Uint8Array(Object.values(decryptedData.proof_authorization_key));
+      await ((_this$chainService$ma5 = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma5 === void 0 ? void 0 : _this$chainService$ma5.loadAuthorizationContext({
+        proof_authorization_key: proofAuthKey
+      }));
+    }
+    const zkAddress = await ((_this$chainService$ma6 = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma6 === void 0 ? void 0 : _this$chainService$ma6.getZkAddress());
+    if (updateStore) {
+      var _this$chainService$ma7, _this$chainService$ma8;
+      await this.chainService.mantaPay.saveMantaPayConfig({
+        address,
+        zkAddress: zkAddress,
+        enabled: true,
+        chain: (_this$chainService$ma7 = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma7 === void 0 ? void 0 : (_this$chainService$ma8 = _this$chainService$ma7.network) === null || _this$chainService$ma8 === void 0 ? void 0 : _this$chainService$ma8.toLowerCase(),
+        isInitialSync: false
+      });
+    }
+    this.isMantaPayEnabled = true;
+    return zkAddress;
+  }
+  async disableMantaPay(address) {
+    var _this$chainService$ma9, _this$chainService$ma10;
+    const config = await this.chainService.mantaPay.getMantaPayConfig(address, _constants2._DEFAULT_MANTA_ZK_CHAIN);
+    if (!config) {
+      return false;
+    }
+    await ((_this$chainService$ma9 = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma9 === void 0 ? void 0 : _this$chainService$ma9.dropAuthorizationContext());
+    await ((_this$chainService$ma10 = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma10 === void 0 ? void 0 : _this$chainService$ma10.dropUserSeedPhrase());
+    // await this.chainService.mantaPay.privateWallet?.resetState();
+    await this.chainService.mantaPay.deleteMantaPayConfig(address, _constants2._DEFAULT_MANTA_ZK_CHAIN);
+    await this.chainService.mantaPay.deleteMantaAuthContext(address, _constants2._DEFAULT_MANTA_ZK_CHAIN);
+    this.chainService.setMantaZkAssetSettings(false);
+    this.isMantaPayEnabled = false;
+    return true;
+  }
+  async initialSyncMantaPay(address) {
+    var _this$chainService$ma11, _this$chainService$ma12, _this$chainService$ma13;
+    if (!address || (0, _utilCrypto.isEthereumAddress)(address)) {
+      return;
+    }
+    this.chainService.mantaPay.setCurrentAddress(address);
+    await ((_this$chainService$ma11 = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma11 === void 0 ? void 0 : (_this$chainService$ma12 = _this$chainService$ma11.baseWallet) === null || _this$chainService$ma12 === void 0 ? void 0 : _this$chainService$ma12.isApiReady());
+    const syncResult = await ((_this$chainService$ma13 = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma13 === void 0 ? void 0 : _this$chainService$ma13.initialWalletSync());
+    await this.chainService.mantaPay.updateMantaPayConfig(address, _constants2._DEFAULT_MANTA_ZK_CHAIN, {
+      isInitialSync: true
+    });
+    this.eventService.emit('mantaPay.initSync', undefined);
+    return syncResult;
+  }
+  getMantaZkBalance() {
+    var _this$chainService, _this$chainService$ma14, _this$chainService$ma15, _this$chainService2, _this$chainService2$m, _this$chainService$ma16;
+    if (!this.chainService || !this.chainService.mantaPay) {
+      return;
+    }
+    if (!((_this$chainService = this.chainService) !== null && _this$chainService !== void 0 && (_this$chainService$ma14 = _this$chainService.mantaPay) !== null && _this$chainService$ma14 !== void 0 && (_this$chainService$ma15 = _this$chainService$ma14.privateWallet) !== null && _this$chainService$ma15 !== void 0 && _this$chainService$ma15.initialSyncIsFinished)) {
+      return;
+    }
+    const chain = (_this$chainService2 = this.chainService) === null || _this$chainService2 === void 0 ? void 0 : (_this$chainService2$m = _this$chainService2.mantaPay.privateWallet) === null || _this$chainService2$m === void 0 ? void 0 : _this$chainService2$m.network;
+    if (!chain) {
+      return;
+    }
+    const assetMap = this.chainService.getMantaZkAssets(chain === null || chain === void 0 ? void 0 : chain.toLowerCase());
+    (_this$chainService$ma16 = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma16 === void 0 ? void 0 : _this$chainService$ma16.getMultiZkBalance(Object.values(assetMap).map(tokenInfo => new _util.BN((0, _utils._getTokenOnChainAssetId)(tokenInfo)))).then(zkBalances => {
+      const assetList = Object.values(assetMap);
+      for (let i = 0; i < assetList.length; i++) {
+        var _zkBalances$i;
+        const balanceItem = {
+          tokenSlug: assetList[i].slug,
+          state: _KoniTypes.APIItemState.PENDING,
+          free: '0',
+          locked: '0'
+        };
+        balanceItem.free = ((_zkBalances$i = zkBalances[i]) === null || _zkBalances$i === void 0 ? void 0 : _zkBalances$i.toString()) || '0';
+        balanceItem.state = _KoniTypes.APIItemState.READY;
+        this.setBalanceItem(balanceItem.tokenSlug, balanceItem);
+      }
+    }).catch(console.warn);
+  }
+  subscribeMantaPayBalance() {
+    let interval;
+    this.chainService.mantaPay.getMantaPayConfig(this.keyringService.currentAccount.address, _constants2._DEFAULT_MANTA_ZK_CHAIN).then(config => {
+      if (config && config.enabled && config.isInitialSync) {
+        this.getMantaZkBalance();
+        interval = setInterval(this.getMantaZkBalance, _constants.MANTA_PAY_BALANCE_INTERVAL);
+      }
+    }).catch(console.warn);
+    return () => {
+      interval && clearInterval(interval);
+    };
+  }
+  async syncMantaPay() {
+    var _this$chainService3, _this$chainService3$m, _this$chainService3$m2;
+    const config = await this.chainService.mantaPay.getMantaPayFirstConfig(_constants2._DEFAULT_MANTA_ZK_CHAIN);
+    if (!config.isInitialSync) {
+      return;
+    }
+    if ((_this$chainService3 = this.chainService) !== null && _this$chainService3 !== void 0 && (_this$chainService3$m = _this$chainService3.mantaPay) !== null && _this$chainService3$m !== void 0 && (_this$chainService3$m2 = _this$chainService3$m.privateWallet) !== null && _this$chainService3$m2 !== void 0 && _this$chainService3$m2.initialSyncIsFinished) {
+      var _this$chainService4, _this$chainService4$m, _this$chainService4$m2;
+      await ((_this$chainService4 = this.chainService) === null || _this$chainService4 === void 0 ? void 0 : (_this$chainService4$m = _this$chainService4.mantaPay) === null || _this$chainService4$m === void 0 ? void 0 : (_this$chainService4$m2 = _this$chainService4$m.privateWallet) === null || _this$chainService4$m2 === void 0 ? void 0 : _this$chainService4$m2.walletSync());
+    } else {
+      var _this$chainService5, _this$chainService5$m, _this$chainService5$m2;
+      await ((_this$chainService5 = this.chainService) === null || _this$chainService5 === void 0 ? void 0 : (_this$chainService5$m = _this$chainService5.mantaPay) === null || _this$chainService5$m === void 0 ? void 0 : (_this$chainService5$m2 = _this$chainService5$m.privateWallet) === null || _this$chainService5$m2 === void 0 ? void 0 : _this$chainService5$m2.initialWalletSync());
+    }
+  }
+  async getMantaPayZkBalance(address, tokenInfo) {
+    var _this$chainService$ma17;
+    const bnAssetId = new _util.BN((0, _utils._getTokenOnChainAssetId)(tokenInfo));
+    const balance = await ((_this$chainService$ma17 = this.chainService.mantaPay.privateWallet) === null || _this$chainService$ma17 === void 0 ? void 0 : _this$chainService$ma17.getZkBalance(bnAssetId));
+    return {
+      decimals: tokenInfo.decimals || 0,
+      symbol: tokenInfo.symbol,
+      value: (balance === null || balance === void 0 ? void 0 : balance.toString()) || '0'
+    };
+  }
+  subscribeMantaPaySyncState() {
+    return this.chainService.mantaPay.subscribeSyncState();
+  }
 }
 exports.default = KoniState;

package/cjs/koni/background/subscription.js

@@ -158,12 +158,15 @@ class KoniSubscription {
     const unsub = (0, _balance.subscribeBalance)(addresses, filteredChainInfoMap, substrateApiMap, evmApiMap, result => {
       this.state.setBalanceItem(result.tokenSlug, result);
     });
+    const unsub2 = this.state.subscribeMantaPayBalance();
     if (onlyRunOnFirstTime) {
       unsub && unsub();
+      unsub2 && unsub2();
       return;
     }
     return () => {
       unsub && unsub();
+      unsub2 && unsub2();
     };
   }
   initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime) {

package/cjs/packageInfo.js

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

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-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._STAKING_CHAIN_GROUP = exports._PURE_EVM_CHAINS = exports._PREDEFINED_SINGLE_MODES = exports._PARACHAIN_INFLATION_DISTRIBUTION = exports._NFT_CHAIN_GROUP = exports._MULTI_CHAIN_ASSET_SRC = exports._KNOWN_CHAIN_INFLATION_PARAMS = 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.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._STAKING_CHAIN_GROUP = 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._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.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");
@@ -38,7 +38,7 @@ const _BALANCE_CHAIN_GROUP = {
   genshiro: ['genshiro_testnet', 'genshiro'],
   equilibrium_parachain: ['equilibrium_parachain'],
   bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main'],
-  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel'],
+  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel', 'calamari'],
   kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'] // perhaps there are some runtime updates
 };
 exports._BALANCE_CHAIN_GROUP = _BALANCE_CHAIN_GROUP;
@@ -207,9 +207,15 @@ exports._TRANSFER_CHAIN_GROUP = _TRANSFER_CHAIN_GROUP;
 const _BALANCE_PARSING_CHAIN_GROUP = {
   bobabeam: ['bobabeam', 'bobabase']
 };
+exports._BALANCE_PARSING_CHAIN_GROUP = _BALANCE_PARSING_CHAIN_GROUP;
+const _MANTA_ZK_CHAIN_GROUP = ['calamari'];
+exports._MANTA_ZK_CHAIN_GROUP = _MANTA_ZK_CHAIN_GROUP;
+const _ZK_ASSET_PREFIX = 'zk';
+exports._ZK_ASSET_PREFIX = _ZK_ASSET_PREFIX;
+const _DEFAULT_MANTA_ZK_CHAIN = 'calamari';
 
 // XCM------------------------------------------------------------------------------------------------------------------
-exports._BALANCE_PARSING_CHAIN_GROUP = _BALANCE_PARSING_CHAIN_GROUP;
+exports._DEFAULT_MANTA_ZK_CHAIN = _DEFAULT_MANTA_ZK_CHAIN;
 const _XCM_CHAIN_GROUP = {
   polkadotXcm: ['astar', 'shiden', 'statemine', 'statemint', 'equilibrium_parachain'],
   xcmPallet: ['polkadot', 'kusama']
@@ -228,7 +234,7 @@ const _DEFAULT_ACTIVE_CHAINS = [..._chainList._DEFAULT_CHAINS];
 
 // TODO: review
 exports._DEFAULT_ACTIVE_CHAINS = _DEFAULT_ACTIVE_CHAINS;
-const TARGET_BRANCH = process.env.NODE_ENV !== 'production' ? 'koni-dev' : 'master';
+const TARGET_BRANCH = process.env.NODE_ENV !== 'production' ? 'koni/dev/issue-15' : 'master';
 const _CHAIN_INFO_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/ChainInfo.json`;
 exports._CHAIN_INFO_SRC = _CHAIN_INFO_SRC;
 const _CHAIN_ASSET_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/ChainAsset.json`;

package/cjs/services/chain-service/handler/SubstrateApi.js

@@ -75,6 +75,7 @@ class SubstrateApi {
   }
   constructor(chainSlug, apiUrl) {
     let {
+      externalApiPromise,
       metadata,
       providerName
     } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
@@ -84,7 +85,7 @@ class SubstrateApi {
     this.registry = new _create.TypeRegistry();
     this.metadata = metadata;
     this.provider = this.createProvider(apiUrl);
-    this.api = this.createApi(this.provider);
+    this.api = externalApiPromise || this.createApi(this.provider);
     this.handleApiReady = (0, _promise.createPromiseHandler)();
     this.api.on('ready', this.onReady.bind(this));
     this.api.on('connected', this.onConnect.bind(this));

package/cjs/services/chain-service/handler/SubstrateChainHandler.js

@@ -182,6 +182,7 @@ class SubstrateChainHandler extends _AbstractChainHandler.AbstractChainHandler {
   async initApi(chainSlug, apiUrl) {
     var _this$parent2;
     let {
+      externalApiPromise,
       onUpdateStatus,
       providerName
     } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
@@ -198,7 +199,8 @@ class SubstrateChainHandler extends _AbstractChainHandler.AbstractChainHandler {
     const metadata = await ((_this$parent2 = this.parent) === null || _this$parent2 === void 0 ? void 0 : _this$parent2.getMetadata(chainSlug));
     const apiObject = new _SubstrateApi2.SubstrateApi(chainSlug, apiUrl, {
       providerName,
-      metadata
+      metadata,
+      externalApiPromise
     });
     apiObject.isApiConnectedSubject.subscribe(this.handleConnect.bind(this, chainSlug));
     onUpdateStatus && apiObject.isApiConnectedSubject.subscribe(onUpdateStatus);

package/cjs/services/chain-service/handler/manta/MantaPrivateHandler.js

@@ -0,0 +1,147 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MantaPrivateHandler = void 0;
+var _mantaExtensionSdk = require("manta-extension-sdk");
+var _rxjs = require("rxjs");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MantaPrivateHandler {
+  _privateWallet = undefined;
+  syncStateSubject = new _rxjs.Subject();
+  constructor(dbService) {
+    this.dbService = dbService;
+    this.syncState = {
+      isSyncing: false,
+      progress: 0
+    };
+    this.syncStateSubject.next(this.syncState);
+  }
+  setCurrentAddress(address) {
+    this.currentAddress = address;
+  }
+  getSyncState() {
+    return this.syncState;
+  }
+  get privateWallet() {
+    return this._privateWallet;
+  }
+  subscribeSyncState() {
+    return this.syncStateSubject;
+  }
+  async updateMantaPayConfig(address, chain, changes) {
+    await this.dbService.updateMantaPayData(`config_${chain}_${address}`, changes);
+  }
+  async saveMantaPayConfig(config) {
+    await this.dbService.setMantaPayData({
+      key: `config_${config.chain}_${config.address}`,
+      ...config
+    });
+  }
+  async getMantaPayConfig(address, chain) {
+    return this.dbService.getMantaPayData(`config_${chain}_${address}`);
+  }
+  async getMantaPayFirstConfig(chain) {
+    return this.dbService.getMantaPayFirstConfig(chain);
+  }
+  async deleteMantaPayConfig(address, chain) {
+    return this.dbService.deleteMantaPayConfig(`config_${chain}_${address}`);
+  }
+  async saveMantaAuthContext(context) {
+    await this.dbService.setMantaPayData({
+      key: `authContext_${context.chain}_${context.address}`,
+      ...context
+    });
+  }
+  async getMantaAuthContext(address, chain) {
+    return this.dbService.getMantaPayData(`authContext_${chain}_${address}`);
+  }
+  async deleteMantaAuthContext(address, chain) {
+    return this.dbService.deleteMantaPayConfig(`authContext_${chain}_${address}`);
+  }
+  async saveLedgerState(palletName, network, data) {
+    try {
+      const suffix = this.currentAddress ? `_${this.currentAddress}` : '';
+      await this.dbService.setMantaPayData({
+        key: `storage_state_${palletName}_${network}${suffix}`,
+        ...data
+      });
+    } catch (e) {
+      console.error('manta-pay', e);
+      return false;
+    }
+    return true;
+  }
+  async getLedgerState(palletName, network) {
+    let result;
+    try {
+      const suffix = this.currentAddress ? `_${this.currentAddress}` : '';
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      result = await this.dbService.getMantaPayData(`storage_state_${palletName}_${network}${suffix}`);
+    } catch (e) {
+      console.error(e);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return result || null;
+  }
+  async initMantaPay(providerUrl, network) {
+    const networkParam = network.charAt(0).toUpperCase() + network.slice(1); // Manta || Calamari || Dolphin
+
+    const baseWallet = await _mantaExtensionSdk.BaseWallet.init({
+      apiEndpoint: providerUrl,
+      loggingEnabled: false,
+      provingFilePath: './manta-pay/proving',
+      parametersFilePath: './manta-pay/parameters',
+      saveStorageStateToLocal: this.saveLedgerState.bind(this),
+      getStorageStateFromLocal: this.getLedgerState.bind(this)
+    });
+    this._privateWallet = _mantaExtensionSdk.MantaPayWallet.init(networkParam, baseWallet);
+    return this._privateWallet.api;
+  }
+  async getCurrentLedgerState() {
+    var _this$_privateWallet;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const ledgerState = await this.getLedgerState('mantaPay', 'Calamari');
+    if (!ledgerState) {
+      return 0;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    return await ((_this$_privateWallet = this._privateWallet) === null || _this$_privateWallet === void 0 ? void 0 : _this$_privateWallet.getLedgerCurrentCount(ledgerState.checkpoint));
+  }
+  setSyncState(data) {
+    this.syncState = data;
+    this.syncStateSubject.next(this.syncState);
+  }
+  async subscribeSyncProgress() {
+    var _this$_privateWallet2;
+    const ledgerTotalCount = await ((_this$_privateWallet2 = this._privateWallet) === null || _this$_privateWallet2 === void 0 ? void 0 : _this$_privateWallet2.getLedgerTotalCount());
+    const interval = setInterval(() => {
+      this.getCurrentLedgerState().then(currentCount => {
+        const progress = Math.floor(currentCount / ledgerTotalCount * 100);
+        if (progress === 100) {
+          this.syncState = {
+            isSyncing: false,
+            progress
+          };
+          clearInterval(interval);
+        } else {
+          this.syncState = {
+            isSyncing: true,
+            progress
+          };
+        }
+        this.syncStateSubject.next(this.syncState);
+      }).catch(console.error);
+    }, 1000);
+    return () => {
+      interval && clearInterval(interval);
+    };
+  }
+}
+exports.MantaPrivateHandler = MantaPrivateHandler;