@subwallet/extension-base 0.8.4-0 → 1.0.1

package/services/history-service/subsquid-multi-chain-history.js

@@ -0,0 +1,251 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ApolloClient, createHttpLink, gql, InMemoryCache } from '@apollo/client';
+import { ChainType, ExtrinsicStatus, ExtrinsicType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
+import fetch from 'cross-fetch';
+import { decodeAddress, encodeAddress, isEthereumAddress } from '@polkadot/util-crypto';
+const MULTI_CHAIN_URL = 'https://squid.subsquid.io/multi-chain-tx/v/v1/graphql';
+const MultiChainTxClient = new ApolloClient({
+  cache: new InMemoryCache(),
+  link: createHttpLink({
+    uri: MULTI_CHAIN_URL,
+    fetch: fetch
+  })
+});
+const query = gql`query transactionQuery($addresses: [String!], $olderThanId: String) {
+  transactionsByAddress(addresses: $addresses, olderThanId: $olderThanId) {
+    _data
+    args
+    chainId
+    id
+    name
+    signer
+    blockNumber
+    blockHash
+    timestamp
+    relatedAddresses
+  }
+}`;
+export let SubsquidTransactionType;
+(function (SubsquidTransactionType) {
+  SubsquidTransactionType["BalanceTransfer"] = "Balances.Transfer";
+  SubsquidTransactionType["EthereumExecuted"] = "Ethereum.Executed";
+  SubsquidTransactionType["StakingBonded"] = "Staking.Bonded";
+  SubsquidTransactionType["CrowdloanContributed"] = "Crowdloan.Contributed";
+})(SubsquidTransactionType || (SubsquidTransactionType = {}));
+const HISTORY_SUPPORT_TYPES = [SubsquidTransactionType.BalanceTransfer, SubsquidTransactionType.EthereumExecuted, SubsquidTransactionType.StakingBonded
+// SubsquidTransactionType.CrowdloanContributed // Not support because data indexer not enough data
+];
+
+function parseData(anyData) {
+  try {
+    return JSON.parse(anyData);
+  } catch (e) {
+    return undefined;
+  }
+}
+function autoFormatAddress(address) {
+  try {
+    if (isEthereumAddress(address)) {
+      return address;
+    } else {
+      const decoded = decodeAddress(address);
+      return encodeAddress(decoded, 42);
+    }
+  } catch (e) {
+    return '';
+  }
+}
+function generateSignature({
+  r,
+  s,
+  v
+}) {
+  const rHex = r.startsWith('0x') ? r.slice(2) : r;
+  const sHex = s.startsWith('0x') ? s.slice(2) : s;
+  const vHex = parseInt(v).toString(16);
+  return `0x${rHex}${sHex}${vHex}`;
+}
+export function parseSubsquidTransactionData(address, type, historyItem, chainInfo, args, data) {
+  var _chainInfo$substrateI, _chainInfo$evmInfo, _chainInfo$substrateI2, _chainInfo$evmInfo2;
+  const chainType = chainInfo.substrateInfo ? ChainType.SUBSTRATE : ChainType.EVM;
+  const nativeDecimals = ((_chainInfo$substrateI = chainInfo.substrateInfo) === null || _chainInfo$substrateI === void 0 ? void 0 : _chainInfo$substrateI.decimals) || ((_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.decimals) || 18;
+  const nativeSymbol = ((_chainInfo$substrateI2 = chainInfo.substrateInfo) === null || _chainInfo$substrateI2 === void 0 ? void 0 : _chainInfo$substrateI2.symbol) || ((_chainInfo$evmInfo2 = chainInfo.evmInfo) === null || _chainInfo$evmInfo2 === void 0 ? void 0 : _chainInfo$evmInfo2.symbol) || '';
+  let from = historyItem.signer;
+  let to = address === historyItem.signer ? historyItem.relatedAddresses.find(a => a !== historyItem.signer) || '' : address;
+  let amount = '0';
+  let fee = '0';
+  let tip = '0';
+  let transactionType = ExtrinsicType.UNKNOWN;
+  let extrinsicHash = '';
+  let signature = '';
+  let success = false;
+  switch (type) {
+    // Parsed Transfer
+    case SubsquidTransactionType.BalanceTransfer:
+      {
+        transactionType = ExtrinsicType.TRANSFER_BALANCE;
+        const extrinsic = data.extrinsic;
+        const parsedArgs = args;
+        to = autoFormatAddress(parsedArgs.to);
+        from = autoFormatAddress(parsedArgs.from);
+        amount = parsedArgs.amount;
+        fee = extrinsic.fee;
+        tip = extrinsic.tip;
+        extrinsicHash = extrinsic.hash;
+        signature = extrinsic.signature;
+        success = extrinsic.success;
+        break;
+      }
+    case SubsquidTransactionType.EthereumExecuted:
+      {
+        // Parsed EVM Transaction
+        transactionType = ExtrinsicType.EVM_EXECUTE;
+        const extrinsic = data.extrinsic;
+        const parsedArgs = args;
+        const transaction = data.call.data.args.transaction.value;
+        to = autoFormatAddress(parsedArgs.to);
+        from = autoFormatAddress(parsedArgs.from);
+        extrinsicHash = parsedArgs.transactionHash;
+        amount = transaction.value;
+        fee = (parseInt(transaction.gasPrice) * parseInt(transaction.gasLimit)).toString();
+        signature = generateSignature(transaction.signature);
+        success = extrinsic.success;
+        break;
+      }
+
+    // Parsed Stake
+    case SubsquidTransactionType.CrowdloanContributed:
+      {
+        transactionType = ExtrinsicType.CROWDLOAN;
+        const callData = data.call.data.args;
+        const extrinsic = data.extrinsic;
+        to = autoFormatAddress('');
+        extrinsicHash = extrinsic.hash;
+        amount = callData.value;
+        fee = extrinsic.fee;
+        signature = extrinsic.signature;
+        success = extrinsic.success;
+        break;
+      }
+    case SubsquidTransactionType.StakingBonded:
+      {
+        transactionType = ExtrinsicType.STAKING_BOND;
+        const callData = data.call.data.args;
+        const extrinsic = data.extrinsic;
+        to = autoFormatAddress('');
+        extrinsicHash = extrinsic.hash;
+        amount = callData.value;
+        fee = extrinsic.fee;
+        signature = extrinsic.signature;
+        success = extrinsic.success;
+        break;
+      }
+  }
+  function toTimestamp(input) {
+    try {
+      if (typeof input === 'string') {
+        return new Date(input).getTime();
+      } else {
+        return input;
+      }
+    } catch (e) {
+      return 0;
+    }
+  }
+  return {
+    address,
+    origin: MULTI_CHAIN_URL,
+    time: toTimestamp(historyItem.timestamp),
+    chainType,
+    from,
+    direction: address === from ? TransactionDirection.SEND : TransactionDirection.RECEIVED,
+    blockNumber: historyItem.blockNumber,
+    blockHash: historyItem.blockHash,
+    chain: historyItem.chainId,
+    data: historyItem._data,
+    type: transactionType,
+    to,
+    signature,
+    extrinsicHash,
+    amount: {
+      value: amount,
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    fee: {
+      value: fee,
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    tip: {
+      value: tip,
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    status: success ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL
+  };
+}
+export async function fetchMultiChainHistories(addresses, chainMap, maxPage = 25) {
+  const responseData = [];
+  let currentPage = 0;
+  let lastId;
+  while (true) {
+    try {
+      if (maxPage) {
+        if (currentPage >= maxPage) {
+          break;
+        }
+        currentPage++;
+      }
+      const response = await MultiChainTxClient.query({
+        query,
+        variables: {
+          addresses,
+          olderThanId: lastId
+        }
+      });
+      const needProcessedData = response.data.transactionsByAddress || [];
+      if (needProcessedData.length > 0) {
+        lastId = response.data.transactionsByAddress[needProcessedData.length - 1].id;
+        responseData.push(...needProcessedData);
+      } else {
+        break;
+      }
+    } catch (e) {
+      break;
+    }
+  }
+  const histories = [];
+  const lowerAddresses = addresses.map(a => a.toLowerCase());
+  responseData.forEach(historyItem => {
+    const {
+      _data,
+      args,
+      chainId,
+      name,
+      relatedAddresses
+    } = historyItem;
+
+    // Ignore not support type
+    if (!HISTORY_SUPPORT_TYPES.includes(name)) {
+      return;
+    }
+    const usedAddresses = relatedAddresses.filter(a => lowerAddresses.includes(a.toLowerCase()));
+    const chainInfo = chainMap[chainId];
+    if (chainInfo === undefined) {
+      console.warn(`Not found chain info for chain id: ${chainId}`);
+      return;
+    }
+    try {
+      usedAddresses.forEach(address => {
+        const transactionData = parseSubsquidTransactionData(address, name, historyItem, chainInfo, parseData(args), parseData(_data));
+        histories.push(transactionData);
+      });
+    } catch (e) {
+      console.warn('Parse transaction data failed', e);
+    }
+  });
+  return histories;
+}

package/services/migration-service/Base.d.ts

@@ -0,0 +1,8 @@
+import State from '@subwallet/extension-base/koni/background/handlers/State';
+import { Logger } from '@polkadot/util/types';
+export default class BaseMigrationJob {
+    readonly state: State;
+    logger: Logger;
+    constructor(state: State);
+    run(): Promise<void>;
+}

package/services/migration-service/Base.js

@@ -0,0 +1,13 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { logger as createLogger } from '@polkadot/util';
+export default class BaseMigrationJob {
+  constructor(state) {
+    this.state = state;
+    this.logger = createLogger(this.constructor.name);
+  }
+  run() {
+    return Promise.resolve(console.warn('Need to override function run from base.'));
+  }
+}

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

@@ -0,0 +1,7 @@
+import State from '@subwallet/extension-base/koni/background/handlers/State';
+export default class MigrationService {
+    readonly state: State;
+    private logger;
+    constructor(state: State);
+    run(): Promise<void>;
+}

package/services/migration-service/index.js

@@ -0,0 +1,37 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { logger as createLogger } from '@polkadot/util';
+import MigrationScripts from "./scripts/index.js";
+export default class MigrationService {
+  constructor(state) {
+    this.state = state;
+    this.logger = createLogger('Migration');
+  }
+  async run() {
+    this.logger.log('Migrating...');
+    const keys = Object.keys(MigrationScripts).sort((a, b) => a.localeCompare(b));
+    try {
+      for (let i = 0; i < keys.length; i++) {
+        const JobClass = MigrationScripts[keys[i]];
+        const check = await this.state.dbService.stores.migration.table.where({
+          name: JobClass.name,
+          key: keys[i]
+        }).first();
+        if (!check) {
+          const job = new JobClass(this.state);
+          this.logger.log('Running script: ', JobClass.name);
+          await job.run();
+          await this.state.dbService.stores.migration.table.put({
+            key: keys[i],
+            name: JobClass.name,
+            timestamp: +new Date()
+          });
+        }
+      }
+    } catch (error) {
+      this.logger.warn('Migration error: ', error);
+    }
+    this.logger.log('Migration done.');
+  }
+}

package/services/migration-service/scripts/ClearOldStorage.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class ClearOldStorage extends BaseMigrationJob {
+    run(): Promise<void>;
+}

package/services/migration-service/scripts/ClearOldStorage.js

@@ -0,0 +1,11 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class ClearOldStorage extends BaseMigrationJob {
+  async run() {
+    // Clear all old storage data
+    await chrome.storage.local.clear();
+    return Promise.resolve();
+  }
+}

package/services/migration-service/scripts/MigrateImportedToken.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateImportedToken extends BaseMigrationJob {
+    run(): Promise<void>;
+}

package/services/migration-service/scripts/MigrateImportedToken.js

@@ -0,0 +1,40 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateImportedToken extends BaseMigrationJob {
+  async run() {
+    const state = this.state;
+    return new Promise((resolve, reject) => {
+      chrome.storage.local.get('EvmToken', function (items) {
+        if (items && items.EvmToken) {
+          const tokenMap = items.EvmToken;
+          Object.entries(tokenMap).forEach(([t, tokenList]) => {
+            tokenList.forEach(item => {
+              try {
+                item.isCustom && state.chainService.upsertCustomToken({
+                  assetType: t.toUpperCase(),
+                  decimals: item.decimals ? parseInt(item.decimals.toString()) : null,
+                  hasValue: true,
+                  metadata: {
+                    contractAddress: item.smartContract
+                  },
+                  minAmount: '0',
+                  multiChainAsset: null,
+                  name: item.name,
+                  originChain: item.chain,
+                  priceId: null,
+                  slug: '',
+                  symbol: item.symbol || ''
+                });
+              } catch (e) {
+                console.log(e);
+              }
+            });
+          });
+        }
+        resolve();
+      });
+    });
+  }
+}

package/services/migration-service/scripts/MigrateNetworkSettings.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateNetworkSettings extends BaseMigrationJob {
+    run(): Promise<void>;
+}

package/services/migration-service/scripts/MigrateNetworkSettings.js

@@ -0,0 +1,30 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateNetworkSettings extends BaseMigrationJob {
+  async run() {
+    const state = this.state;
+    return new Promise((resolve, reject) => {
+      chrome.storage.local.get('NetworkMap', function (items) {
+        if (items && items.NetworkMap) {
+          const networkMap = items.NetworkMap;
+          const enableList = [];
+          const stateMap = state.getChainStateMap();
+          Object.entries(networkMap).forEach(([slug, chain]) => {
+            if (chain.active) {
+              const currentState = stateMap[slug];
+
+              // Ensure chain in the list and is not active
+              currentState && !currentState.active && enableList.push(slug);
+            }
+          });
+          if (enableList.length > 0) {
+            state.chainService.enableChains(enableList);
+          }
+        }
+        resolve();
+      });
+    });
+  }
+}

package/services/migration-service/scripts/index.d.ts

@@ -0,0 +1,3 @@
+import BaseMigrationJob from '../Base';
+declare const _default: Record<string, typeof BaseMigrationJob>;
+export default _default;

package/services/migration-service/scripts/index.js

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import MigrateImportedToken from '@subwallet/extension-base/services/migration-service/scripts/MigrateImportedToken';
+import MigrateNetworkSettings from '@subwallet/extension-base/services/migration-service/scripts/MigrateNetworkSettings';
+export default {
+  '1.0.1-1': MigrateNetworkSettings,
+  '1.0.1-2': MigrateImportedToken
+  // '1.0.1-0': ClearOldStorage
+};

package/services/notification-service/NotificationService.d.ts

@@ -0,0 +1,8 @@
+import { Notification, NotificationParams } from '@subwallet/extension-base/background/KoniTypes';
+import { BehaviorSubject } from 'rxjs';
+export default class NotificationService {
+    private notificationSubject;
+    getNotificationSubject(): BehaviorSubject<Notification[]>;
+    notify(notification: NotificationParams): void;
+    static createBrowserNotification(title: string, message: string, link?: string): void;
+}

package/services/notification-service/NotificationService.js

@@ -0,0 +1,46 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BehaviorSubject } from 'rxjs';
+export default class NotificationService {
+  notificationSubject = new BehaviorSubject([]);
+  getNotificationSubject() {
+    return this.notificationSubject;
+  }
+  notify(notification) {
+    const now = new Date().getTime();
+    // Get values in last 30 seconds only
+    const notifications = this.notificationSubject.value.filter(n => n.id < now - 30000);
+
+    // Push notification
+    notifications.push({
+      ...notification,
+      id: now
+    });
+    this.notificationSubject.next(notifications);
+    if (notification.notifyViaBrowser) {
+      var _notification$action;
+      NotificationService.createBrowserNotification(notification.title, notification.message, notification === null || notification === void 0 ? void 0 : (_notification$action = notification.action) === null || _notification$action === void 0 ? void 0 : _notification$action.url);
+    }
+  }
+
+  // Create a new chrome notification with link
+  static createBrowserNotification(title, message, link) {
+    chrome.notifications.create({
+      type: 'basic',
+      title,
+      message,
+      iconUrl: 'https://subwallet.app/assets/images/favicon/favicon-192x192.png',
+      priority: 2,
+      isClickable: !!link
+    }, notificationId => {
+      if (link) {
+        chrome.notifications.onClicked.addListener(nId => {
+          if (nId === notificationId) {
+            window.open(link);
+          }
+        });
+      }
+    });
+  }
+}

package/services/price-service/coingecko.d.ts

@@ -0,0 +1,2 @@
+import { PriceJson } from '@subwallet/extension-base/background/KoniTypes';
+export declare const getTokenPrice: (priceIds: Set<string>, currency?: string) => Promise<PriceJson>;

package/services/price-service/coingecko.js

@@ -0,0 +1,31 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import axios from 'axios';
+export const getTokenPrice = async (priceIds, currency = 'usd') => {
+  try {
+    const idStr = Array.from(priceIds).join(',');
+    // const res = await axios.get(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=${currency}&per_page=250&ids=${idStr}`);
+    const res = await axios.get(`https://chain-data.subwallet.app/api/price/get?ids=${idStr}`);
+    if (res.status !== 200) {
+      console.warn('Failed to get token price');
+    }
+    const responseData = res.data;
+    const priceMap = {};
+    const price24hMap = {};
+    responseData.forEach(val => {
+      const currentPrice = val.current_price || 0;
+      const price24h = currentPrice - (val.price_change_24h || 0);
+      priceMap[val.id] = currentPrice;
+      price24hMap[val.id] = price24h;
+    });
+    return {
+      currency,
+      priceMap,
+      price24hMap
+    };
+  } catch (err) {
+    console.error('Failed to get token price', err);
+    throw err;
+  }
+};

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

@@ -0,0 +1,16 @@
+import { PriceJson, ServiceInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import { BehaviorSubject, Subject } from 'rxjs';
+export declare class PriceService {
+    private dbService;
+    private chainService;
+    private priceSubject;
+    private refreshTimeout;
+    private priceIds;
+    constructor(serviceInfoSubject: Subject<ServiceInfo>, dbService: DatabaseService, chainService: ChainService);
+    getPrice(): Promise<PriceJson>;
+    getPriceSubject(): BehaviorSubject<PriceJson>;
+    getPriceIds(): Set<string>;
+    refreshPriceData(priceIds?: Set<string>): void;
+}

package/services/price-service/index.js

@@ -0,0 +1,71 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { CRON_REFRESH_PRICE_INTERVAL } from '@subwallet/extension-base/constants';
+import { getTokenPrice } from '@subwallet/extension-base/services/price-service/coingecko';
+import { BehaviorSubject } from 'rxjs';
+const DEFAULT_PRICE_SUBJECT = {
+  ready: false,
+  currency: 'usd',
+  priceMap: {},
+  price24hMap: {}
+};
+export class PriceService {
+  priceSubject = new BehaviorSubject(DEFAULT_PRICE_SUBJECT);
+  priceIds = new Set();
+  constructor(serviceInfoSubject, dbService, chainService) {
+    this.dbService = dbService;
+    this.chainService = chainService;
+
+    // Fetch data from storage
+    this.getPrice().catch(console.error);
+
+    // Add some delay to avoid fetching many times when start extension background
+    // Subscribe service info to update price list
+    setTimeout(() => {
+      this.refreshPriceData();
+      serviceInfoSubject.subscribe(serviceInfo => {
+        const newPriceIds = this.getPriceIds();
+
+        // Compare two set newPriceIds and this.priceIds
+        if (newPriceIds.size !== this.priceIds.size || !Array.from(newPriceIds).every(v => this.priceIds.has(v))) {
+          this.priceIds = newPriceIds;
+          this.refreshPriceData(this.priceIds);
+        }
+      });
+    }, 3000);
+  }
+  async getPrice() {
+    const isReady = this.priceSubject.value.ready;
+    if (!isReady) {
+      const data = await this.dbService.getPriceStore();
+      this.priceSubject.next(data || DEFAULT_PRICE_SUBJECT);
+    }
+    return this.priceSubject.value;
+  }
+  getPriceSubject() {
+    return this.priceSubject;
+  }
+  getPriceIds() {
+    const priceIdList = Object.values(this.chainService.getAssetRegistry()).map(a => a.priceId).filter(a => a);
+    return new Set(priceIdList);
+  }
+  refreshPriceData(priceIds) {
+    clearTimeout(this.refreshTimeout);
+    console.log('Refresh Price Data');
+    this.priceIds = priceIds || this.getPriceIds();
+
+    // Update for tokens price
+    getTokenPrice(this.priceIds).then(rs => {
+      this.priceSubject.next({
+        ...rs,
+        ready: true
+      });
+      this.dbService.updatePriceStore(rs).catch(console.error);
+      console.log('Get Token Price From CoinGecko');
+    }).catch(e => {
+      // Pass
+    });
+    this.refreshTimeout = setTimeout(this.refreshPriceData.bind(this), CRON_REFRESH_PRICE_INTERVAL);
+  }
+}

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

@@ -0,0 +1 @@
+export declare const EXTENSION_REQUEST_URL = "extension";

package/services/request-service/constants.js

@@ -0,0 +1,4 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const EXTENSION_REQUEST_URL = 'extension';

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

@@ -0,0 +1,29 @@
+import { AuthRequestV2 } from '@subwallet/extension-base/background/KoniTypes';
+import { AuthorizeRequest, RequestAuthorizeTab } from '@subwallet/extension-base/background/types';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import RequestService from '@subwallet/extension-base/services/request-service';
+import { AuthUrls } from '@subwallet/extension-base/services/request-service/types';
+import { BehaviorSubject, Subject } from 'rxjs';
+export default class AuthRequestHandler {
+    #private;
+    private readonly authorizeStore;
+    private authorizeCached;
+    private readonly authorizeUrlSubject;
+    private readonly evmChainSubject;
+    readonly authSubjectV2: BehaviorSubject<AuthorizeRequest[]>;
+    constructor(requestService: RequestService, chainService: ChainService);
+    private stripUrl;
+    private getAddressList;
+    get numAuthRequestsV2(): number;
+    private get allAuthRequestsV2();
+    private updateIconAuthV2;
+    setAuthorize(data: AuthUrls, callback?: () => void): void;
+    getAuthorize(update: (value: AuthUrls) => void): void;
+    getAuthList(): Promise<AuthUrls>;
+    private authCompleteV2;
+    authorizeUrlV2(url: string, request: RequestAuthorizeTab): Promise<boolean>;
+    getAuthRequestV2(id: string): AuthRequestV2;
+    get subscribeEvmChainChange(): Subject<AuthUrls>;
+    get subscribeAuthorizeUrlSubject(): Subject<AuthUrls>;
+    ensureUrlAuthorizedV2(url: string): Promise<boolean>;
+}