@subwallet/extension-base 1.2.32-0 → 1.3.1

package/services/request-service/handler/AuthRequestHandler.js

@@ -1,11 +1,13 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { ALL_ACCOUNT_AUTH_TYPES } from '@subwallet/extension-base/constants';
 import { _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
-import { DAPP_CONNECT_ALL_TYPE_ACCOUNT_URL, PREDEFINED_CHAIN_DAPP_CHAIN_MAP, WEB_APP_URL } from '@subwallet/extension-base/services/request-service/constants';
+import { DAPP_CONNECT_BOTH_TYPE_ACCOUNT_URL, PREDEFINED_CHAIN_DAPP_CHAIN_MAP, WEB_APP_URL } from '@subwallet/extension-base/services/request-service/constants';
 import AuthorizeStore from '@subwallet/extension-base/stores/Authorize';
 import { createPromiseHandler, getDomainFromUrl, stripUrl } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
+import { isSubstrateAddress, isTonAddress } from '@subwallet/keyring';
 import { BehaviorSubject } from 'rxjs';
 import { isEthereumAddress } from '@polkadot/util-crypto';
 const AUTH_URLS_KEY = 'authUrls';
@@ -22,27 +24,48 @@ export default class AuthRequestHandler {
     this.keyringService = keyringService;
     this.#requestService = requestService;
     this.#chainService = chainService;
-    this.init().catch(console.error);
+    this.migrateAuthUrlInfoToUnified().then(() => {
+      this.init().catch(console.error);
+    }).catch(console.error);
   }
   async init() {
     const authList = await this.getAuthList();
     let needUpdateAuthList = false;
-    Object.entries(authList).forEach(([key, value]) => {
-      const existKeyAllBothConnect = DAPP_CONNECT_ALL_TYPE_ACCOUNT_URL.find(url_ => url_.includes(key));
-      if (existKeyAllBothConnect && value.accountAuthType !== 'both') {
+    const updatedAuthList = Object.entries(authList).reduce((acc, [key, value]) => {
+      const existKeyBothConnectAuthType = DAPP_CONNECT_BOTH_TYPE_ACCOUNT_URL.some(url_ => url_.includes(key));
+      if (existKeyBothConnectAuthType && (!value.accountAuthTypes || value.accountAuthTypes.length < 2)) {
+        value.accountAuthTypes = ['evm', 'substrate'];
         needUpdateAuthList = true;
-        authList[key] = {
-          ...value,
-          accountAuthType: 'both'
-        };
       }
-    });
+      acc[key] = {
+        ...value
+      };
+      return acc;
+    }, {});
+    if (needUpdateAuthList) {
+      this.setAuthorize(updatedAuthList);
+    }
+  }
+  async migrateAuthUrlInfoToUnified() {
+    const authList = await this.getAuthList();
+    let needUpdateAuthList = false;
+    const updatedAuthList = Object.entries(authList).reduce((acc, [key, value]) => {
+      if ('accountAuthType' in value) {
+        const oldValueStructure = value;
+        needUpdateAuthList = true;
+        value.accountAuthTypes = oldValueStructure.accountAuthType === 'both' ? ['substrate', 'evm'] : [oldValueStructure.accountAuthType || 'substrate'];
+      }
+      acc[key] = {
+        ...value
+      };
+      return acc;
+    }, {});
     if (needUpdateAuthList) {
-      this.setAuthorize(authList);
+      this.setAuthorize(updatedAuthList);
     }
   }
   getAddressList(value = false) {
-    const addressList = Object.keys(this.keyringService.accounts);
+    const addressList = Object.keys(this.keyringService.context.pairs);
     return addressList.reduce((addressList, v) => ({
       ...addressList,
       [v]: value
@@ -108,7 +131,7 @@ export default class AuthRequestHandler {
       }
     }
     let chainInfo;
-    if (['both', 'evm'].includes(options.accessType)) {
+    if (options.accessType === 'evm') {
       const evmChains = Object.values(chainInfoMaps).filter(_isChainEvmCompatible);
       chainInfo = (defaultChain ? chainInfoMaps[defaultChain] : evmChains.find(chain => {
         var _chainStateMap$chain$;
@@ -132,7 +155,6 @@ export default class AuthRequestHandler {
   authCompleteV2 = (id, url, resolve, reject) => {
     const isAllowedMap = this.getAddressList();
     const complete = (result, cb, accounts) => {
-      var _this$getDAppChainInf;
       const isAllowed = result === true;
       let isCancelled = false;
       if (!isAllowed && typeof result === 'object' && result.message === 'Cancelled') {
@@ -143,11 +165,12 @@ export default class AuthRequestHandler {
           isAllowedMap[acc] = true;
         });
       } else {
-        // eslint-disable-next-line no-return-assign
-        Object.keys(isAllowedMap).forEach(address => isAllowedMap[address] = false);
+        Object.keys(isAllowedMap).forEach(address => {
+          isAllowedMap[address] = false;
+        });
       }
       const {
-        accountAuthType,
+        accountAuthTypes,
         idStr,
         request: {
           allowedAccounts,
@@ -155,21 +178,36 @@ export default class AuthRequestHandler {
         },
         url
       } = this.#authRequestsV2[id];
-      if (accountAuthType !== 'both') {
-        const isEvmType = accountAuthType === 'evm';
-        const backupAllowed = [...(allowedAccounts || [])].filter(a => {
-          const isEth = isEthereumAddress(a);
-          return isEvmType ? !isEth : isEth;
+
+      // Note: accountAuthTypes represents the accountAuthType of this request
+      //       allowedAccounts is a list of connected accounts that exist for this origin during this request.
+
+      if (accountAuthTypes.length !== ALL_ACCOUNT_AUTH_TYPES.length) {
+        const backupAllowed = (allowedAccounts || []).filter(a => {
+          if (isEthereumAddress(a) && !accountAuthTypes.includes('evm')) {
+            return true;
+          }
+          if (isSubstrateAddress(a) && !accountAuthTypes.includes('substrate')) {
+            return true;
+          }
+          if (isTonAddress(a) && !accountAuthTypes.includes('ton')) {
+            return true;
+          }
+          return false;
         });
         backupAllowed.forEach(acc => {
           isAllowedMap[acc] = true;
         });
       }
-      const defaultEvmNetworkKey = (_this$getDAppChainInf = this.getDAppChainInfo({
-        accessType: accountAuthType,
-        url,
-        autoActive: !isCancelled && isAllowed
-      })) === null || _this$getDAppChainInf === void 0 ? void 0 : _this$getDAppChainInf.slug;
+      let defaultEvmNetworkKey;
+      if (accountAuthTypes.includes('evm')) {
+        const chainInfo = this.getDAppChainInfo({
+          accessType: 'evm',
+          autoActive: true,
+          url
+        });
+        defaultEvmNetworkKey = chainInfo === null || chainInfo === void 0 ? void 0 : chainInfo.slug;
+      }
       this.getAuthorize(value => {
         let authorizeList = {};
         if (value) {
@@ -191,7 +229,7 @@ export default class AuthRequestHandler {
           isAllowedMap,
           origin,
           url,
-          accountAuthType: existed && existed.accountAuthType !== accountAuthType ? 'both' : accountAuthType,
+          accountAuthTypes: [...new Set([...accountAuthTypes, ...((existed === null || existed === void 0 ? void 0 : existed.accountAuthTypes) || [])])],
           currentEvmNetworkKey: existed ? existed.currentEvmNetworkKey : defaultEvmNetworkKey
         };
         this.setAuthorize(authorizeList, () => {
@@ -221,9 +259,8 @@ export default class AuthRequestHandler {
   async authorizeUrlV2(url, request) {
     let authList = await this.getAuthList();
     const idStr = stripUrl(url);
-    const isAllowedDappConnectAllType = !!DAPP_CONNECT_ALL_TYPE_ACCOUNT_URL.find(url_ => url.includes(url_));
-    let accountAuthType = isAllowedDappConnectAllType ? 'both' : request.accountAuthType || 'substrate';
-    request.accountAuthType = accountAuthType;
+    const isAllowedDappConnectBothType = !!DAPP_CONNECT_BOTH_TYPE_ACCOUNT_URL.find(url_ => url.includes(url_));
+    let accountAuthTypes = [...new Set(isAllowedDappConnectBothType ? ['evm', 'substrate'] : request.accountAuthTypes || ['substrate'])];
     if (!authList) {
       authList = {};
     }
@@ -234,7 +271,10 @@ export default class AuthRequestHandler {
       reject,
       resolve
     } = promiseHandler;
-    const isExistedAuthBothBefore = Object.entries(this.authorizeUrlSubject.value).find(([key, data]) => key === idStr && data.accountAuthType === 'both');
+    const isExistedAuthBothBefore = Object.entries(this.authorizeUrlSubject.value).find(([key, data]) => {
+      var _data$accountAuthType;
+      return key === idStr && ((_data$accountAuthType = data.accountAuthTypes) === null || _data$accountAuthType === void 0 ? void 0 : _data$accountAuthType.length) === ALL_ACCOUNT_AUTH_TYPES.length;
+    });
     if (isExistedAuthBothBefore) {
       return true;
     }
@@ -250,9 +290,9 @@ export default class AuthRequestHandler {
     const mergeKeys = [];
     Object.entries(this.#authRequestsV2).forEach(([key, _request]) => {
       if (_request.idStr === idStr) {
-        if (_request.accountAuthType !== request.accountAuthType) {
-          request.accountAuthType = 'both';
-          accountAuthType = 'both';
+        if (accountAuthTypes && _request.accountAuthTypes) {
+          const filteredAccountAuthTypes = new Set([..._request.accountAuthTypes, ...accountAuthTypes]);
+          accountAuthTypes = [...filteredAccountAuthTypes];
         }
         mergeKeys.push(key);
       }
@@ -267,8 +307,8 @@ export default class AuthRequestHandler {
       });
     }
     const existedAuth = authList[idStr];
-    const existedAccountAuthType = existedAuth === null || existedAuth === void 0 ? void 0 : existedAuth.accountAuthType;
-    const confirmAnotherType = existedAccountAuthType !== 'both' && existedAccountAuthType !== request.accountAuthType;
+    const existedAccountAuthType = existedAuth === null || existedAuth === void 0 ? void 0 : existedAuth.accountAuthTypes;
+    const confirmAnotherType = !existedAccountAuthType || accountAuthTypes.some(type => !existedAccountAuthType.includes(type));
     if (request.reConfirm && existedAuth) {
       request.origin = existedAuth.origin;
     }
@@ -281,11 +321,16 @@ export default class AuthRequestHandler {
       }
       request.allowedAccounts = Object.entries(existedAuth.isAllowedMap).map(([address, allowed]) => allowed ? address : '').filter(item => item !== '');
       let allowedListByRequestType = [...request.allowedAccounts];
-      if (accountAuthType === 'evm') {
-        allowedListByRequestType = allowedListByRequestType.filter(a => isEthereumAddress(a));
-      } else if (accountAuthType === 'substrate') {
-        allowedListByRequestType = allowedListByRequestType.filter(a => !isEthereumAddress(a));
-      }
+      allowedListByRequestType = accountAuthTypes.reduce((list, accountAuthType) => {
+        if (accountAuthType === 'evm') {
+          list.push(...allowedListByRequestType.filter(a => isEthereumAddress(a)));
+        } else if (accountAuthType === 'substrate') {
+          list.push(...allowedListByRequestType.filter(a => isSubstrateAddress(a)));
+        } else if (accountAuthType === 'ton') {
+          list.push(...allowedListByRequestType.filter(a => isTonAddress(a)));
+        }
+        return list;
+      }, []);
       if (!confirmAnotherType && !request.reConfirm && allowedListByRequestType.length !== 0) {
         // Prevent appear confirmation popup
         return false;
@@ -304,7 +349,7 @@ export default class AuthRequestHandler {
           isAllowedMap,
           origin,
           url,
-          accountAuthType: 'both'
+          accountAuthTypes: ALL_ACCOUNT_AUTH_TYPES
         };
         this.setAuthorize(authList);
         return true;
@@ -314,9 +359,12 @@ export default class AuthRequestHandler {
       ...this.authCompleteV2(id, url, resolve, reject),
       id,
       idStr,
-      request,
+      request: {
+        ...request,
+        accountAuthTypes
+      },
       url,
-      accountAuthType: accountAuthType
+      accountAuthTypes: accountAuthTypes || ['substrate']
     };
     this.updateIconAuthV2();
     if (Object.keys(this.#authRequestsV2).length < 2 && !(mergeKeys.length > 0 && mergeKeys[mergeKeys.length - 1] !== id)) {

package/services/request-service/handler/EvmRequestHandler.js

@@ -103,11 +103,10 @@ export default class EvmRequestHandler {
   }
   async signMessage(confirmation) {
     const {
-      account,
+      address,
       payload,
       type
     } = confirmation.payload;
-    const address = account.address;
     const pair = keyring.getPair(address);
     if (pair.isLocked) {
       keyring.unlockPair(pair.address);
@@ -119,7 +118,7 @@ export default class EvmRequestHandler {
       case 'eth_signTypedData_v1':
       case 'eth_signTypedData_v3':
       case 'eth_signTypedData_v4':
-        return await pair.evmSigner.signMessage(payload, type);
+        return await pair.evm.signMessage(payload, type);
       default:
         throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, t('Unsupported action'));
     }
@@ -197,7 +196,7 @@ export default class EvmRequestHandler {
     if (pair.isLocked) {
       keyring.unlockPair(pair.address);
     }
-    return pair.evmSigner.signTransaction(tx);
+    return pair.evm.signTransaction(tx);
   }
   async decorateResult(t, request, result) {
     if (result.payload === '') {

package/services/request-service/handler/SubstrateRequestHandler.d.ts

@@ -1,4 +1,4 @@
-import { AccountJson, RequestSign, ResponseSigning, SigningRequest } from '@subwallet/extension-base/background/types';
+import { RequestSign, ResponseSigning, SigningRequest } from '@subwallet/extension-base/background/types';
 import RequestService from '@subwallet/extension-base/services/request-service';
 import { SignRequest } from '@subwallet/extension-base/services/request-service/types';
 import { BehaviorSubject } from 'rxjs';
@@ -12,7 +12,7 @@ export default class SubstrateRequestHandler {
     private updateIconSign;
     private signComplete;
     get numSubstrateRequests(): number;
-    sign(url: string, request: RequestSign, account: AccountJson, _id?: string): Promise<ResponseSigning>;
+    sign(url: string, request: RequestSign, _id?: string): Promise<ResponseSigning>;
     signTransaction(id: string, address: string, url: string, payload: SignerPayloadJSON): Promise<ResponseSigning>;
     resetWallet(): void;
 }

package/services/request-service/handler/SubstrateRequestHandler.js

@@ -4,7 +4,6 @@
 import RequestExtrinsicSign from '@subwallet/extension-base/background/RequestExtrinsicSign';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import { isInternalRequest } from '@subwallet/extension-base/utils/request';
-import keyring from '@subwallet/ui-keyring';
 import { BehaviorSubject } from 'rxjs';
 import { logger as createLogger } from '@polkadot/util/logger';
 export default class SubstrateRequestHandler {
@@ -21,12 +20,12 @@ export default class SubstrateRequestHandler {
   }
   get allSubstrateRequests() {
     return Object.values(this.#substrateRequests).map(({
-      account,
+      address,
       id,
       request,
       url
     }) => ({
-      account,
+      address,
       id,
       request,
       url,
@@ -57,7 +56,7 @@ export default class SubstrateRequestHandler {
   get numSubstrateRequests() {
     return Object.keys(this.#substrateRequests).length;
   }
-  async sign(url, request, account, _id) {
+  async sign(url, request, _id) {
     const id = _id || getId();
     const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
     if (isAlwaysRequired) {
@@ -66,7 +65,7 @@ export default class SubstrateRequestHandler {
     return new Promise((resolve, reject) => {
       this.#substrateRequests[id] = {
         ...this.signComplete(id, resolve, reject),
-        account,
+        address: request.payload.address,
         id,
         request,
         url
@@ -81,14 +80,9 @@ export default class SubstrateRequestHandler {
       this.#requestService.keyringService.lock();
     }
     return new Promise((resolve, reject) => {
-      const pair = keyring.getPair(address);
-      const account = {
-        address: pair.address,
-        ...pair.meta
-      };
       this.#substrateRequests[id] = {
         ...this.signComplete(id, resolve, reject),
-        account,
+        address,
         id,
         request: new RequestExtrinsicSign(payload),
         url: url

package/services/request-service/handler/TonRequestHandler.d.ts

@@ -0,0 +1,17 @@
+import { ConfirmationDefinitionsTon, ConfirmationsQueueItemOptions, ConfirmationsQueueTon, ConfirmationTypeTon, RequestConfirmationCompleteTon } from '@subwallet/extension-base/background/KoniTypes';
+import RequestService from '@subwallet/extension-base/services/request-service';
+import { BehaviorSubject } from 'rxjs';
+export default class TonRequestHandler {
+    #private;
+    private readonly confirmationsQueueSubjectTon;
+    private readonly confirmationsPromiseMap;
+    constructor(requestService: RequestService);
+    get numTonRequests(): number;
+    getConfirmationsQueueSubjectTon(): BehaviorSubject<ConfirmationsQueueTon>;
+    addConfirmationTon<CT extends ConfirmationTypeTon>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsTon[CT][0]['payload'], // todo: messages <-> payload
+    options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsTon[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsTon[CT][1]>;
+    completeConfirmationTon(request: RequestConfirmationCompleteTon): Promise<boolean>;
+    private decorateResult;
+    private signTransactionTon;
+    resetWallet(): void;
+}

package/services/request-service/handler/TonRequestHandler.js

@@ -0,0 +1,168 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { isInternalRequest } from '@subwallet/extension-base/utils/request';
+import { keyring } from '@subwallet/ui-keyring';
+import { Cell } from '@ton/core';
+import { t } from 'i18next';
+import { BehaviorSubject } from 'rxjs';
+import { u8aToHex } from '@polkadot/util';
+import { logger as createLogger } from '@polkadot/util/logger';
+export default class TonRequestHandler {
+  #requestService;
+  #logger;
+  confirmationsQueueSubjectTon = new BehaviorSubject({
+    tonSignatureRequest: {},
+    tonSendTransactionRequest: {},
+    tonWatchTransactionRequest: {}
+  });
+  confirmationsPromiseMap = {};
+  constructor(requestService) {
+    this.#requestService = requestService;
+    this.#logger = createLogger('TonRequestHandler');
+  }
+  get numTonRequests() {
+    let count = 0;
+    Object.values(this.confirmationsQueueSubjectTon.getValue()).forEach(x => {
+      count += Object.keys(x).length;
+    });
+    return count;
+  }
+  getConfirmationsQueueSubjectTon() {
+    return this.confirmationsQueueSubjectTon;
+  }
+  async addConfirmationTon(id, url, type, payload,
+  // todo: messages <-> payload
+  options = {}, validator) {
+    const confirmations = this.confirmationsQueueSubjectTon.getValue();
+    const confirmationType = confirmations[type];
+    const payloadJson = JSON.stringify({});
+    const isInternal = isInternalRequest(url);
+    if (['tonSendTransactionRequest', 'tonSignatureRequest'].includes(type)) {
+      const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+      if (isAlwaysRequired) {
+        this.#requestService.keyringService.lock();
+      }
+    }
+
+    // Check duplicate request
+    const duplicated = Object.values(confirmationType).find(c => c.url === url && c.payloadJson === payloadJson);
+    if (duplicated) {
+      throw new Error('Ton duplicate request'); // update this message.
+    }
+
+    confirmationType[id] = {
+      id,
+      url,
+      isInternal,
+      payload,
+      payloadJson,
+      ...options
+    };
+    const promise = new Promise((resolve, reject) => {
+      this.confirmationsPromiseMap[id] = {
+        validator: validator,
+        resolver: {
+          resolve: resolve,
+          reject: reject
+        }
+      };
+    });
+    this.confirmationsQueueSubjectTon.next(confirmations);
+    if (!isInternal) {
+      this.#requestService.popupOpen();
+    }
+    this.#requestService.updateIconV2();
+    return promise;
+  }
+  async completeConfirmationTon(request) {
+    const confirmations = this.confirmationsQueueSubjectTon.getValue();
+    for (const ct in request) {
+      const type = ct;
+      const result = request[type];
+      const {
+        id
+      } = result;
+      const {
+        resolver,
+        validator
+      } = this.confirmationsPromiseMap[id];
+      const confirmation = confirmations[type][id];
+      if (!resolver || !confirmation) {
+        this.#logger.error(t('Unable to proceed. Please try again'), type, id);
+        throw new Error(t('Unable to proceed. Please try again'));
+      }
+
+      // Fill signature for some special type
+      await this.decorateResult(type, confirmation, result);
+
+      // Validate response from confirmation popup some info like password, response format....
+      const error = validator && validator(result);
+      if (error) {
+        resolver.reject(error);
+      }
+
+      // Delete confirmations from queue
+      delete this.confirmationsPromiseMap[id];
+      delete confirmations[type][id];
+      this.confirmationsQueueSubjectTon.next(confirmations);
+
+      // Update icon, and close queue
+      this.#requestService.updateIconV2(this.#requestService.numAllRequests === 0);
+      resolver.resolve(result);
+    }
+
+    // TODO: Review later
+    return true;
+  }
+  async decorateResult(t, request, result) {
+    if (result.payload === '') {
+      if (t === 'tonSignatureRequest') {
+        // result.payload = await this.signMessage(request as ConfirmationDefinitions['evmSignatureRequest'][0]);
+      } else if (t === 'tonSendTransactionRequest') {
+        result.payload = this.signTransactionTon(request);
+      }
+      if (t === 'tonSignatureRequest' || t === 'tonSendTransactionRequest') {
+        const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+        if (isAlwaysRequired) {
+          this.#requestService.keyringService.lock();
+        }
+      }
+    }
+  }
+  signTransactionTon(confirmation) {
+    const transaction = confirmation.payload;
+    const {
+      from,
+      messagePayload
+    } = transaction;
+    const pair = keyring.getPair(from);
+    if (pair.isLocked) {
+      keyring.unlockPair(pair.address);
+    }
+    const messages = Cell.fromBase64(messagePayload);
+    const signedTransaction = pair.ton.sign(messages);
+    return u8aToHex(Uint8Array.from(signedTransaction));
+  }
+  resetWallet() {
+    const confirmations = this.confirmationsQueueSubjectTon.getValue();
+    for (const [type, requests] of Object.entries(confirmations)) {
+      for (const confirmation of Object.values(requests)) {
+        const {
+          id
+        } = confirmation;
+        const {
+          resolver
+        } = this.confirmationsPromiseMap[id];
+        if (!resolver || !confirmation) {
+          console.error('Not found confirmation', type, id);
+        } else {
+          resolver.reject(new Error('Reset wallet'));
+        }
+        delete this.confirmationsPromiseMap[id];
+        delete confirmations[type][id];
+      }
+    }
+    this.confirmationsQueueSubjectTon.next(confirmations);
+  }
+}

package/services/request-service/index.d.ts

@@ -1,5 +1,5 @@
-import { AuthRequestV2, ConfirmationDefinitions, ConfirmationsQueue, ConfirmationsQueueItemOptions, ConfirmationType, RequestConfirmationComplete } from '@subwallet/extension-base/background/KoniTypes';
-import { AccountAuthType, AccountJson, AuthorizeRequest, MetadataRequest, RequestAuthorizeTab, RequestSign, ResponseSigning, SigningRequest } from '@subwallet/extension-base/background/types';
+import { AuthRequestV2, ConfirmationDefinitions, ConfirmationDefinitionsTon, ConfirmationsQueue, ConfirmationsQueueItemOptions, ConfirmationsQueueTon, ConfirmationType, ConfirmationTypeTon, RequestConfirmationComplete, RequestConfirmationCompleteTon } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountAuthType, AuthorizeRequest, MetadataRequest, RequestAuthorizeTab, RequestSign, ResponseSigning, SigningRequest } from '@subwallet/extension-base/background/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
@@ -43,14 +43,19 @@ export default class RequestService {
     ensureUrlAuthorizedV2(url: string): Promise<boolean>;
     get signSubject(): BehaviorSubject<SigningRequest[]>;
     get allSubstrateRequests(): SigningRequest[];
-    sign(url: string, request: RequestSign, account: AccountJson, id?: string): Promise<ResponseSigning>;
+    sign(url: string, request: RequestSign, id?: string): Promise<ResponseSigning>;
     get numSubstrateRequests(): number;
     get numEvmRequests(): number;
+    get numTonRequests(): number;
     get confirmationsQueueSubject(): BehaviorSubject<ConfirmationsQueue>;
+    get confirmationsQueueSubjectTon(): BehaviorSubject<ConfirmationsQueueTon>;
     getSignRequest(id: string): import("./types").SignRequest | undefined;
     signInternalTransaction(id: string, address: string, url: string, payload: SignerPayloadJSON): Promise<ResponseSigning>;
     addConfirmation<CT extends ConfirmationType>(id: string, url: string, type: CT, payload: ConfirmationDefinitions[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitions[CT][1]) => Error | undefined): Promise<ConfirmationDefinitions[CT][1]>;
+    addConfirmationTon<CT extends ConfirmationTypeTon>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsTon[CT][0]['payload'], // todo: messages <-> payload
+    options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsTon[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsTon[CT][1]>;
     completeConfirmation(request: RequestConfirmationComplete): Promise<boolean>;
+    completeConfirmationTon(request: RequestConfirmationCompleteTon): Promise<boolean>;
     updateConfirmation<CT extends ConfirmationType>(id: string, type: CT, payload: ConfirmationDefinitions[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitions[CT][1]) => Error | undefined): void;
     getConnectWCRequest(id: string): import("@subwallet/extension-base/services/wallet-connect-service/types").RequestWalletConnectSession;
     get connectWCSubject(): BehaviorSubject<WalletConnectSessionRequest[]>;