@subwallet/extension-base 1.0.12-0 → 1.0.13-1

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

@@ -24,9 +24,13 @@ var _relayChain = require("@subwallet/extension-base/koni/api/staking/bonding/re
 var _transfer3 = require("@subwallet/extension-base/koni/api/tokens/evm/transfer");
 var _wasm = require("@subwallet/extension-base/koni/api/tokens/wasm");
 var _xcm = require("@subwallet/extension-base/koni/api/xcm");
+var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
+var _types2 = require("@subwallet/extension-base/services/chain-service/types");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
-var _constants2 = require("@subwallet/extension-base/services/request-service/constants");
-var _constants3 = require("@subwallet/extension-base/services/setting-service/constants");
+var _constants3 = require("@subwallet/extension-base/services/request-service/constants");
+var _constants4 = require("@subwallet/extension-base/services/setting-service/constants");
+var _constants5 = require("@subwallet/extension-base/services/wallet-connect-service/constants");
+var _helpers2 = require("@subwallet/extension-base/services/wallet-connect-service/helpers");
 var _utils2 = require("@subwallet/extension-base/utils");
 var _address2 = require("@subwallet/extension-base/utils/address");
 var _eth = require("@subwallet/extension-base/utils/eth");
@@ -34,9 +38,10 @@ var _parseTransaction2 = require("@subwallet/extension-base/utils/eth/parseTrans
 var _number = require("@subwallet/extension-base/utils/number");
 var _keyring = require("@subwallet/keyring");
 var _uiKeyring = require("@subwallet/ui-keyring");
+var _utils3 = require("@walletconnect/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _ethereumjsTx = require("ethereumjs-tx");
-var _types2 = require("@polkadot/types");
+var _types3 = require("@polkadot/types");
 var _util = require("@polkadot/util");
 var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
@@ -69,14 +74,17 @@ const ACCOUNT_ALL_JSON = {
 class KoniExtension {
   #lockTimeOut = undefined;
   #koniState;
-  #timeAutoLock = _constants3.DEFAULT_AUTO_LOCK_TIME;
+  #timeAutoLock = _constants4.DEFAULT_AUTO_LOCK_TIME;
+  #skipAutoLock = false;
   constructor(state) {
     this.#koniState = state;
     const updateTimeAutoLock = rs => {
       this.#timeAutoLock = rs.timeAutoLock;
       clearTimeout(this.#lockTimeOut);
       this.#lockTimeOut = setTimeout(() => {
-        this.keyringLock();
+        if (!this.#skipAutoLock) {
+          this.keyringLock();
+        }
       }, this.#timeAutoLock * 60 * 1000);
     };
     this.#koniState.settingService.getSettings(updateTimeAutoLock);
@@ -365,9 +373,26 @@ class KoniExtension {
     });
     return true;
   }
-  windowOpen(path) {
-    const url = `${chrome.extension.getURL('index.html')}#${path}`;
+  windowOpen(_ref18) {
+    let {
+      allowedPath: path,
+      params,
+      subPath
+    } = _ref18;
+    let paramString = '';
+    if (params) {
+      paramString += '?';
+      for (let i = 0; i < Object.keys(params).length; i++) {
+        const [key, value] = Object.entries(params)[i];
+        paramString += `${key}=${value}`;
+        if (i !== Object.keys(params).length - 1) {
+          paramString += '&';
+        }
+      }
+    }
+    const url = `${chrome.extension.getURL('index.html')}#${path}${subPath || ''}${paramString}`;
     if (!_defaults.ALLOWED_PATH.includes(path)) {
+      console.error('Not allowed to open the url:', url);
       return false;
     }
     (0, _helpers.withErrorLog)(() => chrome.tabs.create({
@@ -388,26 +413,26 @@ class KoniExtension {
       throw new Error(`"${suri}" is not a valid derivation path`);
     }
   }
-  derivationValidate(_ref18) {
+  derivationValidate(_ref19) {
     let {
       parentAddress,
       parentPassword,
       suri
-    } = _ref18;
+    } = _ref19;
     const childPair = this.derive(parentAddress, suri, parentPassword, {});
     return {
       address: childPair.address,
       suri
     };
   }
-  derivationCreate(_ref19) {
+  derivationCreate(_ref20) {
     let {
       genesisHash,
       name,
       parentAddress,
       parentPassword,
       suri
-    } = _ref19;
+    } = _ref20;
     const childPair = this.derive(parentAddress, suri, parentPassword, {
       genesisHash,
       name,
@@ -432,11 +457,11 @@ class KoniExtension {
   encodeAddress = (key, ss58Format) => {
     return _uiKeyring.keyring.encodeAddress(key, ss58Format);
   };
-  accountExportPrivateKey(_ref20) {
+  accountExportPrivateKey(_ref21) {
     let {
       address,
       password
-    } = _ref20;
+    } = _ref21;
     return this.#koniState.accountExportPrivateKey({
       address,
       password
@@ -510,27 +535,27 @@ class KoniExtension {
       addresses: (0, _address2.convertSubjectInfoToAddresses)(subjectInfo)
     };
   }
-  saveRecentAccount(_ref21) {
+  saveRecentAccount(_ref22) {
     let {
       accountId
-    } = _ref21;
+    } = _ref22;
     if ((0, _utilCrypto.isAddress)(accountId)) {
       const address = (0, _utils2.reformatAddress)(accountId);
       const account = _uiKeyring.keyring.getAccount(address);
       const contact = _uiKeyring.keyring.getAddress(address);
       return account || contact || {
-        ..._uiKeyring.keyring.saveRecent(accountId).json,
+        ..._uiKeyring.keyring.saveRecent(address).json,
         publicKey: (0, _utilCrypto.decodeAddress)(address)
       };
     } else {
       throw Error('Invalid address');
     }
   }
-  editContactAccount(_ref22) {
+  editContactAccount(_ref23) {
     let {
       address,
       meta
-    } = _ref22;
+    } = _ref23;
     if ((0, _utilCrypto.isAddress)(address)) {
       const _address = (0, _utils2.reformatAddress)(address);
       _uiKeyring.keyring.saveAddress(_address, meta);
@@ -539,10 +564,10 @@ class KoniExtension {
       throw Error('Invalid address');
     }
   }
-  deleteContactAccount(_ref23) {
+  deleteContactAccount(_ref24) {
     let {
       address
-    } = _ref23;
+    } = _ref24;
     if ((0, _utilCrypto.isAddress)(address)) {
       const _address = (0, _utils2.reformatAddress)(address);
       _uiKeyring.keyring.forgetAddress(_address);
@@ -591,11 +616,11 @@ class KoniExtension {
       list: authList
     };
   }
-  authorizeApproveV2(_ref24) {
+  authorizeApproveV2(_ref25) {
     let {
       accounts,
       id
-    } = _ref24;
+    } = _ref25;
     const queued = this.#koniState.getAuthRequestV2(id);
     (0, _util.assert)(queued, 'Unable to find request');
     const {
@@ -607,10 +632,10 @@ class KoniExtension {
     });
     return true;
   }
-  authorizeRejectV2(_ref25) {
+  authorizeRejectV2(_ref26) {
     let {
       id
-    } = _ref25;
+    } = _ref26;
     const queued = this.#koniState.getAuthRequestV2(id);
     (0, _util.assert)(queued, 'Unable to find request');
     const {
@@ -619,10 +644,10 @@ class KoniExtension {
     reject(new Error('Rejected'));
     return true;
   }
-  authorizeCancelV2(_ref26) {
+  authorizeCancelV2(_ref27) {
     let {
       id
-    } = _ref26;
+    } = _ref27;
     const queued = this.#koniState.getAuthRequestV2(id);
     (0, _util.assert)(queued, 'Unable to find request');
     const {
@@ -847,10 +872,10 @@ class KoniExtension {
     });
     return true;
   }
-  setCamera(_ref27) {
+  setCamera(_ref28) {
     let {
       camera
-    } = _ref27;
+    } = _ref28;
     this.#koniState.setCamera(camera);
     return true;
   }
@@ -862,10 +887,10 @@ class KoniExtension {
     });
     return true;
   }
-  setAutoLockTime(_ref28) {
+  setAutoLockTime(_ref29) {
     let {
       autoLockTime
-    } = _ref28;
+    } = _ref29;
     this.#koniState.setAutoLockTime(autoLockTime);
     return true;
   }
@@ -882,10 +907,10 @@ class KoniExtension {
     });
     return await this.getSettings();
   }
-  setEnableChainPatrol(_ref29) {
+  setEnableChainPatrol(_ref30) {
     let {
       enable
-    } = _ref29;
+    } = _ref30;
     this.#koniState.setEnableChainPatrol(enable);
     return true;
   }
@@ -1061,7 +1086,7 @@ class KoniExtension {
       }
     });
   }
-  async accountsCreateSuriV2(_ref30) {
+  async accountsCreateSuriV2(_ref31) {
     let {
       genesisHash,
       isAllowed,
@@ -1069,7 +1094,7 @@ class KoniExtension {
       password,
       suri: _suri,
       types
-    } = _ref30;
+    } = _ref31;
     const addressDict = {};
     let changedAccount = false;
     const hasMasterPassword = _uiKeyring.keyring.keyring.hasMasterPassword;
@@ -1117,10 +1142,10 @@ class KoniExtension {
     });
     return addressDict;
   }
-  async accountsForgetOverride(_ref31) {
+  async accountsForgetOverride(_ref32) {
     let {
       address
-    } = _ref31;
+    } = _ref32;
     _uiKeyring.keyring.forgetAccount(address);
     await new Promise(resolve => {
       this.#koniState.removeAccountRef(address, () => {
@@ -1150,14 +1175,15 @@ class KoniExtension {
         address: _constants.ALL_ACCOUNT_KEY
       }, resolve);
     });
+    await this.#koniState.disableMantaPay(address);
     return true;
   }
-  seedCreateV2(_ref32) {
+  seedCreateV2(_ref33) {
     let {
       length = _Extension.SEED_DEFAULT_LENGTH,
       seed: _seed,
       types
-    } = _ref32;
+    } = _ref33;
     const seed = _seed || (0, _utilCrypto.mnemonicGenerate)(length);
     const rs = {
       seed: seed,
@@ -1168,11 +1194,11 @@ class KoniExtension {
     });
     return rs;
   }
-  seedValidateV2(_ref33) {
+  seedValidateV2(_ref34) {
     let {
       suri,
       types
-    } = _ref33;
+    } = _ref34;
     const {
       phrase
     } = (0, _utilCrypto.keyExtractSuri)(suri);
@@ -1192,11 +1218,11 @@ class KoniExtension {
     });
     return rs;
   }
-  _checkValidatePrivateKey(_ref34) {
+  _checkValidatePrivateKey(_ref35) {
     let {
       suri,
       types
-    } = _ref34;
+    } = _ref35;
     let autoAddPrefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       phrase
@@ -1219,11 +1245,11 @@ class KoniExtension {
     }
     return rs;
   }
-  metamaskPrivateKeyValidateV2(_ref35) {
+  metamaskPrivateKeyValidateV2(_ref36) {
     let {
       suri,
       types
-    } = _ref35;
+    } = _ref36;
     const isValidSuri = suri.startsWith('0x');
     if (isValidSuri) {
       return this._checkValidatePrivateKey({
@@ -1248,14 +1274,14 @@ class KoniExtension {
       throw new Error(`"${suri}" is not a valid derivation path`);
     }
   }
-  derivationCreateV2(_ref36) {
+  derivationCreateV2(_ref37) {
     let {
       genesisHash,
       isAllowed,
       name,
       parentAddress,
       suri
-    } = _ref36;
+    } = _ref37;
     const childPair = this.deriveV2(parentAddress, suri, {
       genesisHash,
       name,
@@ -1269,14 +1295,14 @@ class KoniExtension {
     });
     return true;
   }
-  jsonRestoreV2(_ref37) {
+  jsonRestoreV2(_ref38) {
     let {
       address,
       file,
       isAllowed,
       password,
       withMasterPassword
-    } = _ref37;
+    } = _ref38;
     const isPasswordValidated = this.validatePassword(file, password);
     if (isPasswordValidated) {
       try {
@@ -1291,13 +1317,13 @@ class KoniExtension {
       throw new Error('Unable to decode using the supplied passphrase');
     }
   }
-  batchRestoreV2(_ref38) {
+  batchRestoreV2(_ref39) {
     let {
       accountsInfo,
       file,
       isAllowed,
       password
-    } = _ref38;
+    } = _ref39;
     const addressList = accountsInfo.map(acc => acc.address);
     const isPasswordValidated = this.validatedAccountsPassword(file, password);
     if (isPasswordValidated) {
@@ -1452,7 +1478,11 @@ class KoniExtension {
     let transaction;
 
     // Get native token amount
-    const freeBalance = await this.#koniState.balanceService.getTokenFreeBalance(from, networkKey, tokenSlug);
+    const freeBalance = await this.getAddressFreeBalance({
+      address: from,
+      networkKey,
+      token: tokenSlug
+    });
     try {
       if ((0, _utilCrypto.isEthereumAddress)(from) && (0, _utilCrypto.isEthereumAddress)(to) && (0, _utils._isTokenTransferredByEvm)(tokenInfo)) {
         // TODO: review this
@@ -1465,6 +1495,10 @@ class KoniExtension {
         } else {
           [transaction, transferAmount.value] = await (0, _transfer3.getEVMTransactionObject)(chainInfo, to, txVal, !!transferAll, evmApiMap);
         }
+      } else if ((0, _utils._isMantaZkAsset)(tokenInfo)) {
+        // TODO
+        transaction = undefined;
+        transferAmount.value = '0';
       } else {
         const substrateApi = this.#koniState.getSubstrateApi(networkKey);
         [transaction, transferAmount.value] = await (0, _transfer.createTransferExtrinsic)({
@@ -1493,14 +1527,22 @@ class KoniExtension {
       if (!isTransferNativeToken) {
         const {
           value: balance
-        } = await this.#koniState.balanceService.getTokenFreeBalance(from, networkKey, tokenSlug);
+        } = await this.getAddressFreeBalance({
+          address: from,
+          networkKey,
+          token: tokenSlug
+        });
         if (new _bignumber.default(balance).minus(transferAmount.value).lt(minAmount)) {
           inputTransaction.warnings.push(new _TransactionWarning.TransactionWarning(_KoniTypes.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, ''));
         }
       }
       const {
         value: receiverBalance
-      } = await this.#koniState.balanceService.getTokenFreeBalance(to, networkKey, tokenSlug);
+      } = await this.getAddressFreeBalance({
+        address: from,
+        networkKey,
+        token: tokenSlug
+      });
       if (new _bignumber.default(receiverBalance).plus(transferAmount.value).lt(minAmount)) {
         const atLeast = new _bignumber.default(minAmount).minus(receiverBalance).plus((tokenInfo.decimals || 0) === 0 ? 0 : 1);
         const atLeastStr = (0, _number.formatNumber)(atLeast, tokenInfo.decimals || 0, _number.balanceFormatter);
@@ -1600,7 +1642,7 @@ class KoniExtension {
     // this.addContact(to);
 
     return await this.#koniState.transactionService.handleTransaction({
-      url: _constants2.EXTENSION_REQUEST_URL,
+      url: _constants3.EXTENSION_REQUEST_URL,
       address: from,
       chain: originNetworkKey,
       transaction: extrinsic,
@@ -1635,7 +1677,7 @@ class KoniExtension {
       data: inputData,
       extrinsicType: _KoniTypes.ExtrinsicType.SEND_NFT,
       transaction,
-      url: _constants2.EXTENSION_REQUEST_URL
+      url: _constants3.EXTENSION_REQUEST_URL
     });
   }
   async upsertChain(data) {
@@ -1652,18 +1694,18 @@ class KoniExtension {
   disableChain(networkKey) {
     return this.#koniState.disableChain(networkKey);
   }
-  async enableChain(_ref39) {
+  async enableChain(_ref40) {
     let {
       chainSlug,
       enableTokens
-    } = _ref39;
+    } = _ref40;
     return await this.#koniState.enableChain(chainSlug, enableTokens);
   }
-  async validateNetwork(_ref40) {
+  async validateNetwork(_ref41) {
     let {
       existedChainSlug,
       provider
-    } = _ref40;
+    } = _ref41;
     return await this.#koniState.validateCustomChain(provider, existedChainSlug);
   }
   resetDefaultNetwork() {
@@ -1701,23 +1743,33 @@ class KoniExtension {
   async validateCustomAsset(data) {
     return await this.#koniState.validateCustomAsset(data);
   }
-  async getAddressFreeBalance(_ref41) {
+  async getAddressFreeBalance(_ref42) {
     let {
       address,
       networkKey,
       token
-    } = _ref41;
+    } = _ref42;
+    if (token && _constants2._MANTA_ZK_CHAIN_GROUP.includes(networkKey)) {
+      const tokenInfo = this.#koniState.chainService.getAssetBySlug(token);
+      if (tokenInfo.symbol.startsWith(_constants2._ZK_ASSET_PREFIX)) {
+        return await this.#koniState.getMantaPayZkBalance(address, tokenInfo);
+      }
+    }
     return await this.#koniState.balanceService.getTokenFreeBalance(address, networkKey, token);
   }
-  async transferGetMaxTransferable(_ref42) {
+  async transferGetMaxTransferable(_ref43) {
     let {
       address,
       destChain,
       isXcmTransfer,
       networkKey,
       token
-    } = _ref42;
-    const freeBalance = await this.#koniState.balanceService.getTokenFreeBalance(address, networkKey, token);
+    } = _ref43;
+    const freeBalance = await this.getAddressFreeBalance({
+      address,
+      networkKey,
+      token
+    });
     const tokenInfo = token ? this.#koniState.chainService.getAssetBySlug(token) : this.#koniState.chainService.getNativeTokenInfo(networkKey);
     if (!(0, _utils._isNativeToken)(tokenInfo)) {
       return freeBalance;
@@ -1787,12 +1839,12 @@ class KoniExtension {
       };
     }
   }
-  async subscribeAddressFreeBalance(_ref43, id, port) {
+  async subscribeAddressFreeBalance(_ref44, id, port) {
     let {
       address,
       networkKey,
       token
-    } = _ref43;
+    } = _ref44;
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const [unsub, currentFreeBalance] = await this.#koniState.balanceService.subscribeTokenFreeBalance(address, networkKey, token, cb);
     this.createUnsubscriptionHandle(id, unsub);
@@ -1801,26 +1853,26 @@ class KoniExtension {
     });
     return currentFreeBalance;
   }
-  async transferCheckReferenceCount(_ref44) {
+  async transferCheckReferenceCount(_ref45) {
     let {
       address,
       networkKey
-    } = _ref44;
+    } = _ref45;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-return
     return await (0, _transfer.checkReferenceCount)(networkKey, address, this.#koniState.getSubstrateApiMap(), this.#koniState.getChainInfo(networkKey));
   }
-  async transferCheckSupporting(_ref45) {
+  async transferCheckSupporting(_ref46) {
     let {
       networkKey,
       tokenSlug
-    } = _ref45;
+    } = _ref46;
     const tokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
     return await (0, _transfer.checkSupportTransfer)(networkKey, tokenInfo, this.#koniState.getSubstrateApiMap(), this.#koniState.getChainInfo(networkKey));
   }
-  transferGetExistentialDeposit(_ref46) {
+  transferGetExistentialDeposit(_ref47) {
     let {
       tokenSlug
-    } = _ref46;
+    } = _ref47;
     const tokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
     return (0, _utils._getTokenMinAmount)(tokenInfo);
   }
@@ -1856,11 +1908,11 @@ class KoniExtension {
       isSendingSelf
     };
   }
-  async enableChains(_ref47) {
+  async enableChains(_ref48) {
     let {
       chainSlugs,
       enableTokens
-    } = _ref47;
+    } = _ref48;
     try {
       await Promise.all(chainSlugs.map(chainSlug => this.enableChain({
         chainSlug,
@@ -1871,24 +1923,24 @@ class KoniExtension {
     }
     return true;
   }
-  getAccountMeta(_ref48) {
+  getAccountMeta(_ref49) {
     let {
       address
-    } = _ref48;
+    } = _ref49;
     const pair = _uiKeyring.keyring.getPair(address);
     (0, _util.assert)(pair, 'Unable to find pair');
     return {
       meta: pair.meta
     };
   }
-  accountsTie2(_ref49) {
+  accountsTie2(_ref50) {
     let {
       address,
       genesisHash
-    } = _ref49;
+    } = _ref50;
     return this.#koniState.setAccountTie(address, genesisHash);
   }
-  async accountsCreateExternalV2(_ref50) {
+  async accountsCreateExternalV2(_ref51) {
     let {
       address,
       genesisHash,
@@ -1896,7 +1948,7 @@ class KoniExtension {
       isEthereum,
       isReadOnly,
       name
-    } = _ref50;
+    } = _ref51;
     try {
       let result;
       try {
@@ -1955,7 +2007,7 @@ class KoniExtension {
       }];
     }
   }
-  async accountsCreateHardwareV2(_ref51) {
+  async accountsCreateHardwareV2(_ref52) {
     let {
       accountIndex,
       address,
@@ -1964,7 +2016,7 @@ class KoniExtension {
       hardwareType,
       isAllowed,
       name
-    } = _ref51;
+    } = _ref52;
     const key = _uiKeyring.keyring.addHardware(address, hardwareType, {
       accountIndex,
       addressOffset,
@@ -1987,10 +2039,10 @@ class KoniExtension {
     });
     return true;
   }
-  async accountsCreateHardwareMultiple(_ref52) {
+  async accountsCreateHardwareMultiple(_ref53) {
     let {
       accounts
-    } = _ref52;
+    } = _ref53;
     const addresses = [];
     if (!accounts.length) {
       throw new Error('No accounts to import');
@@ -2068,14 +2120,14 @@ class KoniExtension {
     }
     return true;
   }
-  async accountsCreateWithSecret(_ref53) {
+  async accountsCreateWithSecret(_ref54) {
     let {
       isAllow,
       isEthereum,
       name,
       publicKey,
       secretKey
-    } = _ref53;
+    } = _ref54;
     try {
       let keyringPair = null;
       if (isEthereum) {
@@ -2218,30 +2270,30 @@ class KoniExtension {
 
   // Parse transaction
 
-  parseSubstrateTransaction(_ref54) {
+  parseSubstrateTransaction(_ref55) {
     let {
       data,
       networkKey
-    } = _ref54;
+    } = _ref55;
     const apiProps = this.#koniState.getSubstrateApi(networkKey);
     const apiPromise = apiProps.api;
     return (0, _parseTransaction.parseSubstrateTransaction)(data, apiPromise);
   }
-  async parseEVMRLP(_ref55) {
+  async parseEVMRLP(_ref56) {
     let {
       data
-    } = _ref55;
+    } = _ref56;
     return await (0, _parseTransaction2.parseEvmRlp)(data, this.#koniState.getChainInfoMap(), this.#koniState.getEvmApiMap());
   }
 
   // Sign
 
-  qrSignSubstrate(_ref56) {
+  qrSignSubstrate(_ref57) {
     let {
       address,
       data,
       networkKey
-    } = _ref56;
+    } = _ref57;
     const pair = _uiKeyring.keyring.getPair(address);
     (0, _util.assert)(pair, 'Unable to find pair');
     if (pair.isLocked) {
@@ -2258,13 +2310,13 @@ class KoniExtension {
       signature: signed
     };
   }
-  async qrSignEVM(_ref57) {
+  async qrSignEVM(_ref58) {
     let {
       address,
       chainId,
       message,
       type
-    } = _ref57;
+    } = _ref58;
     let signed;
     const network = this.getNetworkJsonByChainId(chainId);
     if (!network) {
@@ -2345,11 +2397,11 @@ class KoniExtension {
     });
     return this.#koniState.getNominatorMetadata();
   }
-  async getBondingOptions(_ref58) {
+  async getBondingOptions(_ref59) {
     let {
       chain,
       type
-    } = _ref58;
+    } = _ref59;
     const apiProps = this.#koniState.getSubstrateApi(chain);
     const chainInfo = this.#koniState.getChainInfo(chain);
     const chainStakingMetadata = await this.#koniState.getStakingMetadataByChain(chain, type);
@@ -2391,7 +2443,7 @@ class KoniExtension {
       data: inputData,
       extrinsicType: _KoniTypes.ExtrinsicType.STAKING_BOND,
       transaction: extrinsic,
-      url: _constants2.EXTENSION_REQUEST_URL,
+      url: _constants3.EXTENSION_REQUEST_URL,
       transferNativeAmount: amount
     });
   }
@@ -2538,12 +2590,12 @@ class KoniExtension {
   }
 
   // EVM Transaction
-  async parseContractInput(_ref59) {
+  async parseContractInput(_ref60) {
     let {
       chainId,
       contract,
       data
-    } = _ref59;
+    } = _ref60;
     const network = this.getNetworkJsonByChainId(chainId);
     return await (0, _parseTransaction2.parseContractInput)(data, contract, network);
   }
@@ -2614,12 +2666,12 @@ class KoniExtension {
 
   // Change master password
 
-  keyringChangeMasterPassword(_ref60) {
+  keyringChangeMasterPassword(_ref61) {
     let {
       createNew,
       newPassword,
       oldPassword
-    } = _ref60;
+    } = _ref61;
     try {
       // Remove isMasterPassword meta if createNew
       if (createNew) {
@@ -2653,11 +2705,11 @@ class KoniExtension {
 
   // Migrate password
 
-  keyringMigrateMasterPassword(_ref61) {
+  keyringMigrateMasterPassword(_ref62) {
     let {
       address,
       password
-    } = _ref61;
+    } = _ref62;
     try {
       _uiKeyring.keyring.migrateWithMasterPassword(address, password);
     } catch (e) {
@@ -2675,12 +2727,13 @@ class KoniExtension {
 
   // Unlock wallet
 
-  keyringUnlock(_ref62) {
+  keyringUnlock(_ref63) {
     let {
       password
-    } = _ref62;
+    } = _ref63;
     try {
       _uiKeyring.keyring.unlockKeyring(password);
+      this.#koniState.initMantaPay(password).catch(console.error);
     } catch (e) {
       return {
         errors: [e.message],
@@ -2704,11 +2757,11 @@ class KoniExtension {
 
   // Export mnemonic
 
-  keyringExportMnemonic(_ref63) {
+  keyringExportMnemonic(_ref64) {
     let {
       address,
       password
-    } = _ref63;
+    } = _ref64;
     const pair = _uiKeyring.keyring.getPair(address);
     const result = pair.exportMnemonic(password);
     return {
@@ -2718,10 +2771,10 @@ class KoniExtension {
 
   // Reset wallet
 
-  async resetWallet(_ref64) {
+  async resetWallet(_ref65) {
     let {
       resetAll
-    } = _ref64;
+    } = _ref65;
     try {
       await this.#koniState.resetWallet(resetAll);
       return {
@@ -2737,10 +2790,10 @@ class KoniExtension {
   }
 
   /// Signing external request
-  signingApprovePasswordV2(_ref65) {
+  signingApprovePasswordV2(_ref66) {
     let {
       id
-    } = _ref65;
+    } = _ref66;
     const queued = this.#koniState.getSignRequest(id);
     (0, _util.assert)(queued, 'Unable to find request');
     const {
@@ -2766,7 +2819,7 @@ class KoniExtension {
     const {
       payload
     } = request;
-    const registry = new _types2.TypeRegistry();
+    const registry = new _types3.TypeRegistry();
     let isEvm = false;
     if ((0, _Extension.isJsonPayload)(payload)) {
       // Get the metadata for the genesisHash
@@ -2793,22 +2846,22 @@ class KoniExtension {
 
   /// Derive account
 
-  derivationCreateMultiple(_ref66) {
+  derivationCreateMultiple(_ref67) {
     let {
       isAllowed,
       items,
       parentAddress
-    } = _ref66;
+    } = _ref67;
     const parentPair = _uiKeyring.keyring.getPair(parentAddress);
     const isEvm = parentPair.type === 'ethereum';
     if (parentPair.isLocked) {
       _uiKeyring.keyring.unlockPair(parentPair.address);
     }
-    const createChild = _ref67 => {
+    const createChild = _ref68 => {
       let {
         name,
         suri
-      } = _ref67;
+      } = _ref68;
       const meta = {
         name: name,
         parentAddress
@@ -2854,10 +2907,10 @@ class KoniExtension {
     }
     return true;
   }
-  derivationCreateV3(_ref68) {
+  derivationCreateV3(_ref69) {
     let {
       address: parentAddress
-    } = _ref68;
+    } = _ref69;
     const parentPair = _uiKeyring.keyring.getPair(parentAddress);
     const isEvm = parentPair.type === 'ethereum';
     if (parentPair.isLocked) {
@@ -2889,11 +2942,11 @@ class KoniExtension {
     });
     return true;
   }
-  validateDerivePath(_ref69) {
+  validateDerivePath(_ref70) {
     let {
       parentAddress,
       suri
-    } = _ref69;
+    } = _ref70;
     const parentPair = _uiKeyring.keyring.getPair(parentAddress);
     const isEvm = parentPair.type === 'ethereum';
     if (parentPair.isLocked) {
@@ -2926,12 +2979,12 @@ class KoniExtension {
       suri: meta.suri
     };
   }
-  getListDeriveAccounts(_ref70) {
+  getListDeriveAccounts(_ref71) {
     let {
       limit,
       page,
       parentAddress
-    } = _ref70;
+    } = _ref71;
     const parentPair = _uiKeyring.keyring.getPair(parentAddress);
     const isEvm = parentPair.type === 'ethereum';
     if (parentPair.isLocked) {
@@ -3022,10 +3075,10 @@ class KoniExtension {
   getSupportedSmartContractTypes() {
     return this.#koniState.getSupportedSmartContractTypes();
   }
-  getTransaction(_ref71) {
+  getTransaction(_ref72) {
     let {
       id
-    } = _ref71;
+    } = _ref72;
     const {
       transaction,
       ...transactionResult
@@ -3035,8 +3088,8 @@ class KoniExtension {
   subscribeTransactions(id, port) {
     const cb = (0, _subscriptions.createSubscription)(id, port);
     function convertRs(rs) {
-      return Object.fromEntries(Object.entries(rs).map(_ref72 => {
-        let [key, value] = _ref72;
+      return Object.fromEntries(Object.entries(rs).map(_ref73 => {
+        let [key, value] = _ref73;
         const {
           additionalValidator,
           eventsHandler,
@@ -3068,10 +3121,10 @@ class KoniExtension {
     });
     return notificationSubject.value;
   }
-  async reloadCron(_ref73) {
+  async reloadCron(_ref74) {
     let {
       data
-    } = _ref73;
+    } = _ref74;
     if (data === 'nft') {
       return await this.#koniState.reloadNft();
     } else if (data === 'staking') {
@@ -3089,19 +3142,269 @@ class KoniExtension {
 
   // Phishing detect
 
-  async passPhishingPage(_ref74) {
+  async passPhishingPage(_ref75) {
     let {
       url
-    } = _ref74;
+    } = _ref75;
     return await this.#koniState.approvePassPhishingPage(url);
   }
 
+  /// Wallet connect
+
+  // Connect
+  async connectWalletConnect(_ref76) {
+    let {
+      uri
+    } = _ref76;
+    await this.#koniState.walletConnectService.connect(uri);
+    return true;
+  }
+  connectWCSubscribe(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const subscription = this.#koniState.requestService.connectWCSubject.subscribe(requests => cb(requests));
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+      subscription.unsubscribe();
+    });
+    return this.#koniState.requestService.allConnectWCRequests;
+  }
+  async approveWalletConnectSession(_ref77) {
+    let {
+      accounts: selectedAccounts,
+      id
+    } = _ref77;
+    const request = this.#koniState.requestService.getConnectWCRequest(id);
+    if ((0, _helpers2.isProposalExpired)(request.request.params)) {
+      throw new Error('The proposal has been expired');
+    }
+    const wcId = request.request.id;
+    const params = request.request.params;
+    const requiredNamespaces = params.requiredNamespaces;
+    const optionalNamespaces = params.optionalNamespaces;
+    const availableNamespaces = {};
+    const namespaces = {};
+    const chainInfoMap = this.#koniState.getChainInfoMap();
+    Object.entries(requiredNamespaces).forEach(_ref78 => {
+      let [key, namespace] = _ref78;
+      if ((0, _helpers2.isSupportWalletConnectNamespace)(key)) {
+        if (namespace.chains) {
+          const unSupportChains = namespace.chains.filter(chain => !(0, _helpers2.isSupportWalletConnectChain)(chain, chainInfoMap));
+          if (unSupportChains.length) {
+            throw new Error((0, _utils3.getSdkError)('UNSUPPORTED_CHAINS').message + ' ' + unSupportChains.toString());
+          }
+          availableNamespaces[key] = namespace;
+        }
+      } else {
+        throw new Error((0, _utils3.getSdkError)('UNSUPPORTED_NAMESPACE_KEY').message + ' ' + key);
+      }
+    });
+    Object.entries(optionalNamespaces).forEach(_ref79 => {
+      let [key, namespace] = _ref79;
+      if ((0, _helpers2.isSupportWalletConnectNamespace)(key)) {
+        if (namespace.chains) {
+          const supportChains = namespace.chains.filter(chain => (0, _helpers2.isSupportWalletConnectChain)(chain, chainInfoMap)) || [];
+          const requiredNameSpace = availableNamespaces[key];
+          const defaultChains = [];
+          if (requiredNameSpace) {
+            availableNamespaces[key] = {
+              chains: [...(requiredNameSpace.chains || defaultChains), ...(supportChains || defaultChains)],
+              events: requiredNameSpace.events,
+              methods: requiredNameSpace.methods
+            };
+          } else {
+            if (supportChains.length) {
+              availableNamespaces[key] = {
+                chains: supportChains,
+                events: namespace.events,
+                methods: namespace.methods
+              };
+            }
+          }
+        }
+      }
+    });
+    Object.entries(availableNamespaces).forEach(_ref80 => {
+      let [key, namespace] = _ref80;
+      if (namespace.chains) {
+        const accounts = [];
+        const chains = (0, _utils2.uniqueStringArray)(namespace.chains);
+        chains.forEach(chain => {
+          accounts.push(...selectedAccounts.filter(address => (0, _utilCrypto.isEthereumAddress)(address) === (key === _constants5.WALLET_CONNECT_EIP155_NAMESPACE)).map(address => `${chain}:${address}`));
+        });
+        namespaces[key] = {
+          accounts,
+          methods: namespace.methods,
+          events: namespace.events,
+          chains: chains
+        };
+      }
+    });
+    const result = {
+      id: wcId,
+      namespaces: namespaces,
+      relayProtocol: params.relays[0].protocol
+    };
+    await this.#koniState.walletConnectService.approveSession(result);
+    request.resolve();
+    return true;
+  }
+  async rejectWalletConnectSession(_ref81) {
+    let {
+      id
+    } = _ref81;
+    const request = this.#koniState.requestService.getConnectWCRequest(id);
+    const wcId = request.request.id;
+    if ((0, _helpers2.isProposalExpired)(request.request.params)) {
+      request.reject(new Error('The proposal has been expired'));
+      return true;
+    }
+    await this.#koniState.walletConnectService.rejectSession(wcId);
+    request.reject(new Error('USER_REJECTED'));
+    return true;
+  }
+  subscribeWalletConnectSessions(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const subscription = this.#koniState.walletConnectService.sessionSubject.subscribe(rs => {
+      cb(rs);
+    });
+    port.onDisconnect.addListener(() => {
+      subscription.unsubscribe();
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.walletConnectService.sessions;
+  }
+  async disconnectWalletConnectSession(_ref82) {
+    let {
+      topic
+    } = _ref82;
+    await this.#koniState.walletConnectService.disconnect(topic);
+    return true;
+  }
+  async enableMantaPay(_ref83) {
+    let {
+      address,
+      password
+    } = _ref83;
+    // always takes the current account
+    function timeout() {
+      return new Promise(resolve => setTimeout(resolve, 1500));
+    }
+    try {
+      await this.#koniState.chainService.enableChain(_constants2._DEFAULT_MANTA_ZK_CHAIN);
+      this.#koniState.chainService.setMantaZkAssetSettings(true);
+      const mnemonic = this.keyringExportMnemonic({
+        address,
+        password
+      });
+      const {
+        connectionStatus
+      } = this.#koniState.chainService.getChainStateByKey(_constants2._DEFAULT_MANTA_ZK_CHAIN);
+      if (connectionStatus !== _types2._ChainConnectionStatus.CONNECTED) {
+        // TODO: do better
+        await timeout();
+      }
+      const result = await this.#koniState.enableMantaPay(true, address, password, mnemonic.result);
+      this.#skipAutoLock = true;
+      await this.saveCurrentAccountAddress({
+        address
+      });
+      const unsubSyncProgress = await this.#koniState.chainService.mantaPay.subscribeSyncProgress();
+      console.debug('Start initial sync for MantaPay');
+      this.#koniState.initialSyncMantaPay(address).then(() => {
+        console.debug('Finished initial sync for MantaPay');
+        this.#skipAutoLock = false;
+        unsubSyncProgress();
+      }).catch(e => {
+        console.error('Error syncing MantaPay', e);
+        this.#skipAutoLock = false;
+        unsubSyncProgress();
+      });
+      return {
+        success: !!result,
+        message: result ? _KoniTypes.MantaPayEnableMessage.SUCCESS : _KoniTypes.MantaPayEnableMessage.UNKNOWN_ERROR
+      };
+    } catch (e) {
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+      if (e.toString() === 'Error: Unable to decode using the supplied passphrase') {
+        return {
+          success: false,
+          message: _KoniTypes.MantaPayEnableMessage.WRONG_PASSWORD
+        };
+      }
+      return {
+        success: false,
+        message: _KoniTypes.MantaPayEnableMessage.UNKNOWN_ERROR
+      };
+    }
+  }
+  async initSyncMantaPay(address) {
+    if (this.#koniState.chainService.mantaPay.getSyncState().isSyncing) {
+      return;
+    }
+    this.#skipAutoLock = true;
+    await this.saveCurrentAccountAddress({
+      address
+    });
+    const unsubSyncProgress = await this.#koniState.chainService.mantaPay.subscribeSyncProgress();
+    console.debug('Start initial sync for MantaPay');
+    this.#koniState.initialSyncMantaPay(address).then(() => {
+      console.debug('Finished initial sync for MantaPay');
+      this.#skipAutoLock = false;
+      unsubSyncProgress();
+      // make sure the sync state is set, just in case it gets unsubscribed
+      this.#koniState.chainService.mantaPay.setSyncState({
+        progress: 100,
+        isSyncing: false
+      });
+    }).catch(e => {
+      console.error('Error syncing MantaPay', e);
+      this.#skipAutoLock = false;
+      unsubSyncProgress();
+      this.#koniState.chainService.mantaPay.setSyncState({
+        progress: 0,
+        isSyncing: false
+      });
+    });
+  }
+  async disableMantaPay(address) {
+    return this.#koniState.disableMantaPay(address);
+  }
+  subscribeMantaPayConfig(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const mantaPayConfigSubscription = this.#koniState.subscribeMantaPayConfig().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, mantaPayConfigSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.getMantaPayConfig('calamari');
+  }
+  subscribeMantaPaySyncState(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const syncingStateSubscription = this.#koniState.subscribeMantaPaySyncState().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, syncingStateSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.chainService.mantaPay.getSyncState();
+  }
+
   // --------------------------------------------------------------
   // eslint-disable-next-line @typescript-eslint/require-await
   async handle(id, type, request, port) {
     clearTimeout(this.#lockTimeOut);
     this.#lockTimeOut = setTimeout(() => {
-      this.keyringLock();
+      if (!this.#skipAutoLock) {
+        this.keyringLock();
+      }
     }, this.#timeAutoLock * 60 * 1000);
     switch (type) {
       /// Clone from PolkadotJs
@@ -3469,6 +3772,29 @@ class KoniExtension {
       case 'pri(settings.getLogoMaps)':
         return await this.getLogoMap();
 
+      /// Wallet Connect
+      case 'pri(walletConnect.connect)':
+        return this.connectWalletConnect(request);
+      case 'pri(walletConnect.requests.subscribe)':
+        return this.connectWCSubscribe(id, port);
+      case 'pri(walletConnect.session.approve)':
+        return this.approveWalletConnectSession(request);
+      case 'pri(walletConnect.session.reject)':
+        return this.rejectWalletConnectSession(request);
+      case 'pri(walletConnect.session.subscribe)':
+        return this.subscribeWalletConnectSessions(id, port);
+      case 'pri(walletConnect.session.disconnect)':
+        return this.disconnectWalletConnectSession(request);
+      case 'pri(mantaPay.enable)':
+        return await this.enableMantaPay(request);
+      case 'pri(mantaPay.initSyncMantaPay)':
+        return await this.initSyncMantaPay(request);
+      case 'pri(mantaPay.subscribeConfig)':
+        return await this.subscribeMantaPayConfig(id, port);
+      case 'pri(mantaPay.disable)':
+        return await this.disableMantaPay(request);
+      case 'pri(mantaPay.subscribeSyncingState)':
+        return this.subscribeMantaPaySyncState(id, port);
       // Default
       default:
         throw new Error(`Unable to handle message of type ${type}`);