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

package/koni/background/handlers/Extension.js

@@ -7,7 +7,7 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { isJsonPayload, SEED_DEFAULT_LENGTH, SEED_LENGTHS } from '@subwallet/extension-base/background/handlers/Extension';
 import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
 import { createSubscription } from '@subwallet/extension-base/background/handlers/subscriptions';
-import { AccountExternalErrorCode, BasicTxErrorType, BasicTxWarningCode, ChainType, ExternalRequestPromiseStatus, ExtrinsicType, StakingType, TransferTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountExternalErrorCode, BasicTxErrorType, BasicTxWarningCode, ChainType, ExternalRequestPromiseStatus, ExtrinsicType, MantaPayEnableMessage, StakingType, TransferTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
 import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
 import { ALL_ACCOUNT_KEY, ALL_GENESIS_HASH, XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
 import { ALLOWED_PATH } from '@subwallet/extension-base/defaults';
@@ -20,16 +20,21 @@ import { getPoolingBondingExtrinsic, getPoolingUnbondingExtrinsic, validatePoolB
 import { getERC20TransactionObject, getERC721Transaction, getEVMTransactionObject } from '@subwallet/extension-base/koni/api/tokens/evm/transfer';
 import { getPSP34TransferExtrinsic } from '@subwallet/extension-base/koni/api/tokens/wasm';
 import { createXcmExtrinsic } from '@subwallet/extension-base/koni/api/xcm';
-import { _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _getSubstrateGenesisHash, _getTokenMinAmount, _isAssetSmartContractNft, _isChainEvmCompatible, _isCustomAsset, _isLocalToken, _isNativeToken, _isTokenEvmSmartContract, _isTokenTransferredByEvm } from '@subwallet/extension-base/services/chain-service/utils';
+import { _DEFAULT_MANTA_ZK_CHAIN, _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
+import { _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
+import { _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _getSubstrateGenesisHash, _getTokenMinAmount, _isAssetSmartContractNft, _isChainEvmCompatible, _isCustomAsset, _isLocalToken, _isMantaZkAsset, _isNativeToken, _isTokenEvmSmartContract, _isTokenTransferredByEvm } from '@subwallet/extension-base/services/chain-service/utils';
 import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
 import { DEFAULT_AUTO_LOCK_TIME } from '@subwallet/extension-base/services/setting-service/constants';
-import { reformatAddress } from '@subwallet/extension-base/utils';
+import { WALLET_CONNECT_EIP155_NAMESPACE } from '@subwallet/extension-base/services/wallet-connect-service/constants';
+import { isProposalExpired, isSupportWalletConnectChain, isSupportWalletConnectNamespace } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
+import { reformatAddress, uniqueStringArray } from '@subwallet/extension-base/utils';
 import { convertSubjectInfoToAddresses } from '@subwallet/extension-base/utils/address';
 import { createTransactionFromRLP, signatureToHex } from '@subwallet/extension-base/utils/eth';
 import { parseContractInput, parseEvmRlp } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { balanceFormatter, formatNumber } from '@subwallet/extension-base/utils/number';
 import { createPair } from '@subwallet/keyring';
 import { keyring } from '@subwallet/ui-keyring';
+import { getSdkError } from '@walletconnect/utils';
 import BigN from 'bignumber.js';
 import { Transaction } from 'ethereumjs-tx';
 import { TypeRegistry } from '@polkadot/types';
@@ -60,13 +65,16 @@ export default class KoniExtension {
   #lockTimeOut = undefined;
   #koniState;
   #timeAutoLock = 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);
@@ -339,9 +347,25 @@ export default class KoniExtension {
     });
     return true;
   }
-  windowOpen(path) {
-    const url = `${chrome.extension.getURL('index.html')}#${path}`;
+  windowOpen({
+    allowedPath: path,
+    params,
+    subPath
+  }) {
+    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 (!ALLOWED_PATH.includes(path)) {
+      console.error('Not allowed to open the url:', url);
       return false;
     }
     withErrorLog(() => chrome.tabs.create({
@@ -489,7 +513,7 @@ export default class KoniExtension {
       const account = keyring.getAccount(address);
       const contact = keyring.getAddress(address);
       return account || contact || {
-        ...keyring.saveRecent(accountId).json,
+        ...keyring.saveRecent(address).json,
         publicKey: decodeAddress(address)
       };
     } else {
@@ -1110,6 +1134,7 @@ export default class KoniExtension {
         address: ALL_ACCOUNT_KEY
       }, resolve);
     });
+    await this.#koniState.disableMantaPay(address);
     return true;
   }
   seedCreateV2({
@@ -1404,7 +1429,11 @@ export default 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 (isEthereumAddress(from) && isEthereumAddress(to) && _isTokenTransferredByEvm(tokenInfo)) {
         // TODO: review this
@@ -1417,6 +1446,10 @@ export default class KoniExtension {
         } else {
           [transaction, transferAmount.value] = await getEVMTransactionObject(chainInfo, to, txVal, !!transferAll, evmApiMap);
         }
+      } else if (_isMantaZkAsset(tokenInfo)) {
+        // TODO
+        transaction = undefined;
+        transferAmount.value = '0';
       } else {
         const substrateApi = this.#koniState.getSubstrateApi(networkKey);
         [transaction, transferAmount.value] = await createTransferExtrinsic({
@@ -1445,14 +1478,22 @@ export default 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 BigN(balance).minus(transferAmount.value).lt(minAmount)) {
           inputTransaction.warnings.push(new TransactionWarning(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 BigN(receiverBalance).plus(transferAmount.value).lt(minAmount)) {
         const atLeast = new BigN(minAmount).minus(receiverBalance).plus((tokenInfo.decimals || 0) === 0 ? 0 : 1);
         const atLeastStr = formatNumber(atLeast, tokenInfo.decimals || 0, balanceFormatter);
@@ -1656,6 +1697,12 @@ export default class KoniExtension {
     networkKey,
     token
   }) {
+    if (token && _MANTA_ZK_CHAIN_GROUP.includes(networkKey)) {
+      const tokenInfo = this.#koniState.chainService.getAssetBySlug(token);
+      if (tokenInfo.symbol.startsWith(_ZK_ASSET_PREFIX)) {
+        return await this.#koniState.getMantaPayZkBalance(address, tokenInfo);
+      }
+    }
     return await this.#koniState.balanceService.getTokenFreeBalance(address, networkKey, token);
   }
   async transferGetMaxTransferable({
@@ -1665,7 +1712,11 @@ export default class KoniExtension {
     networkKey,
     token
   }) {
-    const freeBalance = await this.#koniState.balanceService.getTokenFreeBalance(address, networkKey, token);
+    const freeBalance = await this.getAddressFreeBalance({
+      address,
+      networkKey,
+      token
+    });
     const tokenInfo = token ? this.#koniState.chainService.getAssetBySlug(token) : this.#koniState.chainService.getNativeTokenInfo(networkKey);
     if (!_isNativeToken(tokenInfo)) {
       return freeBalance;
@@ -2609,6 +2660,7 @@ export default class KoniExtension {
   }) {
     try {
       keyring.unlockKeyring(password);
+      this.#koniState.initMantaPay(password).catch(console.error);
     } catch (e) {
       return {
         errors: [e.message],
@@ -3012,12 +3064,254 @@ export default class KoniExtension {
     return await this.#koniState.approvePassPhishingPage(url);
   }
 
+  /// Wallet connect
+
+  // Connect
+  async connectWalletConnect({
+    uri
+  }) {
+    await this.#koniState.walletConnectService.connect(uri);
+    return true;
+  }
+  connectWCSubscribe(id, port) {
+    const cb = 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({
+    accounts: selectedAccounts,
+    id
+  }) {
+    const request = this.#koniState.requestService.getConnectWCRequest(id);
+    if (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(([key, namespace]) => {
+      if (isSupportWalletConnectNamespace(key)) {
+        if (namespace.chains) {
+          const unSupportChains = namespace.chains.filter(chain => !isSupportWalletConnectChain(chain, chainInfoMap));
+          if (unSupportChains.length) {
+            throw new Error(getSdkError('UNSUPPORTED_CHAINS').message + ' ' + unSupportChains.toString());
+          }
+          availableNamespaces[key] = namespace;
+        }
+      } else {
+        throw new Error(getSdkError('UNSUPPORTED_NAMESPACE_KEY').message + ' ' + key);
+      }
+    });
+    Object.entries(optionalNamespaces).forEach(([key, namespace]) => {
+      if (isSupportWalletConnectNamespace(key)) {
+        if (namespace.chains) {
+          const supportChains = namespace.chains.filter(chain => 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(([key, namespace]) => {
+      if (namespace.chains) {
+        const accounts = [];
+        const chains = uniqueStringArray(namespace.chains);
+        chains.forEach(chain => {
+          accounts.push(...selectedAccounts.filter(address => isEthereumAddress(address) === (key === 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({
+    id
+  }) {
+    const request = this.#koniState.requestService.getConnectWCRequest(id);
+    const wcId = request.request.id;
+    if (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 = 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({
+    topic
+  }) {
+    await this.#koniState.walletConnectService.disconnect(topic);
+    return true;
+  }
+  async enableMantaPay({
+    address,
+    password
+  }) {
+    // always takes the current account
+    function timeout() {
+      return new Promise(resolve => setTimeout(resolve, 1500));
+    }
+    try {
+      await this.#koniState.chainService.enableChain(_DEFAULT_MANTA_ZK_CHAIN);
+      this.#koniState.chainService.setMantaZkAssetSettings(true);
+      const mnemonic = this.keyringExportMnemonic({
+        address,
+        password
+      });
+      const {
+        connectionStatus
+      } = this.#koniState.chainService.getChainStateByKey(_DEFAULT_MANTA_ZK_CHAIN);
+      if (connectionStatus !== _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 ? MantaPayEnableMessage.SUCCESS : 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: MantaPayEnableMessage.WRONG_PASSWORD
+        };
+      }
+      return {
+        success: false,
+        message: 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 = 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 = 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
@@ -3385,6 +3679,29 @@ export default 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}`);

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

@@ -1,10 +1,10 @@
 /// <reference types="chrome" />
 import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
-import { AddTokenRequestExternal, ApiMap, AuthRequestV2, BalanceItem, BalanceJson, BrowserConfirmationType, ChainStakingMetadata, ConfirmationsQueue, CrowdloanItem, CrowdloanJson, CurrentAccountInfo, EvmSendTransactionParams, ExternalRequestPromise, NftCollection, NftItem, NftJson, NominatorMetadata, RequestAccountExportPrivateKey, RequestCheckPublicAndSecretKey, RequestConfirmationComplete, RequestSettingsType, ResponseAccountExportPrivateKey, ResponseCheckPublicAndSecretKey, ServiceInfo, SingleModeJson, StakingItem, StakingJson, StakingRewardItem, StakingRewardJson, StakingType, ThemeNames, UiSettings } from '@subwallet/extension-base/background/KoniTypes';
+import { AddTokenRequestExternal, AmountData, ApiMap, AuthRequestV2, BalanceItem, BalanceJson, BrowserConfirmationType, ChainStakingMetadata, ConfirmationsQueue, CrowdloanItem, CrowdloanJson, CurrentAccountInfo, EvmSendTransactionParams, ExternalRequestPromise, MantaPayConfig, NftCollection, NftItem, NftJson, NominatorMetadata, RequestAccountExportPrivateKey, RequestCheckPublicAndSecretKey, RequestConfirmationComplete, RequestSettingsType, ResponseAccountExportPrivateKey, ResponseCheckPublicAndSecretKey, ServiceInfo, SingleModeJson, StakingItem, StakingJson, StakingRewardItem, StakingRewardJson, StakingType, ThemeNames, UiSettings } from '@subwallet/extension-base/background/KoniTypes';
 import { AccountJson, RequestAuthorizeTab, RequestRpcSend, RequestRpcSubscribe, RequestRpcUnsubscribe, RequestSign, ResponseRpcListProviders, ResponseSigning } from '@subwallet/extension-base/background/types';
 import { BalanceService } from '@subwallet/extension-base/services/balance-service';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
-import { _ChainConnectionStatus, _ChainState, _NetworkUpsertParams, _ValidateCustomAssetRequest } from '@subwallet/extension-base/services/chain-service/types';
+import { _ChainState, _NetworkUpsertParams, _ValidateCustomAssetRequest } from '@subwallet/extension-base/services/chain-service/types';
 import { EventService } from '@subwallet/extension-base/services/event-service';
 import { HistoryService } from '@subwallet/extension-base/services/history-service';
 import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
@@ -17,6 +17,7 @@ import SettingService from '@subwallet/extension-base/services/setting-service/S
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { SubscanService } from '@subwallet/extension-base/services/subscan-service';
 import TransactionService from '@subwallet/extension-base/services/transaction-service';
+import WalletConnectService from '@subwallet/extension-base/services/wallet-connect-service';
 import { MetadataDef, ProviderMeta } from '@subwallet/extension-inject/types';
 import SimpleKeyring from 'eth-simple-keyring';
 import { BehaviorSubject, Subject } from 'rxjs';
@@ -36,6 +37,8 @@ export default class KoniState {
     private crowdloanMap;
     private crowdloanSubject;
     private nftSubject;
+    private mantaPayConfigSubject;
+    isMantaPayEnabled: boolean;
     private stakingSubject;
     private chainStakingMetadataSubject;
     private stakingNominatorMetadataSubject;
@@ -58,6 +61,7 @@ export default class KoniState {
     readonly balanceService: BalanceService;
     readonly migrationService: MigrationService;
     readonly subscanService: SubscanService;
+    readonly walletConnectService: WalletConnectService;
     private generalStatus;
     private waitSleeping;
     private waitStarting;
@@ -77,6 +81,7 @@ export default class KoniState {
     get authSubjectV2(): BehaviorSubject<import("@subwallet/extension-base/background/types").AuthorizeRequest[]>;
     generateDefaultBalanceMap(): Record<string, BalanceItem>;
     init(): Promise<void>;
+    initMantaPay(password: string): Promise<void>;
     private startSubscription;
     onReady(): void;
     updateKeyringState(isReady?: boolean, callback?: () => void): void;
@@ -94,9 +99,11 @@ export default class KoniState {
     getChainStakingMetadata(): Promise<ChainStakingMetadata[]>;
     getStakingMetadataByChain(chain: string, type: StakingType): Promise<ChainStakingMetadata | undefined>;
     getNominatorMetadata(): Promise<NominatorMetadata[]>;
+    getMantaPayConfig(chain: string): Promise<MantaPayConfig[]>;
     getStaking(): Promise<StakingJson>;
     getStakingOwnersByChains(chains: string[]): Promise<string[]>;
     getPooledStakingRecordsByAddress(addresses: string[]): Promise<StakingItem[]>;
+    subscribeMantaPayConfig(): Subject<MantaPayConfig[]>;
     subscribeStaking(): Subject<StakingJson>;
     subscribeChainStakingMetadata(): Subject<ChainStakingMetadata[]>;
     subscribeNominatorMetadata(): Subject<NominatorMetadata[]>;
@@ -219,7 +226,6 @@ export default class KoniState {
     wakeup(): Promise<void>;
     cancelSubscription(id: string): boolean;
     createUnsubscriptionHandle(id: string, unsubscribe: () => void): void;
-    updateChainConnectionStatus(chain: string, status: _ChainConnectionStatus): void;
     autoEnableChains(addresses: string[]): Promise<void>;
     onAccountAdd(): void;
     onAccountRemove(): void;
@@ -227,5 +233,13 @@ export default class KoniState {
     reloadStaking(): Promise<boolean>;
     approvePassPhishingPage(_url: string): Promise<boolean>;
     resetWallet(resetAll: boolean): Promise<void>;
+    enableMantaPay(updateStore: boolean, address: string, password: string, seedPhrase?: string): Promise<string | undefined>;
+    disableMantaPay(address: string): Promise<boolean>;
+    initialSyncMantaPay(address: string): Promise<boolean | undefined>;
+    getMantaZkBalance(): void;
+    subscribeMantaPayBalance(): () => void;
+    syncMantaPay(): Promise<void>;
+    getMantaPayZkBalance(address: string, tokenInfo: _ChainAsset): Promise<AmountData>;
+    subscribeMantaPaySyncState(): Subject<import("@subwallet/extension-base/background/KoniTypes").MantaPaySyncState>;
 }
 export {};