@subwallet/extension-base 0.7.10-0 → 0.8.1-wr2x

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

@@ -0,0 +1,243 @@
+// 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;
+      }
+  }
+  return {
+    address,
+    origin: MULTI_CHAIN_URL,
+    time: 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++;
+      }
+      console.log('Fetching history page ' + currentPage.toString(), lastId);
+      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;
+        console.log(lastId);
+        responseData.push(...needProcessedData);
+      } else {
+        break;
+      }
+    } catch (e) {
+      break;
+    }
+  }
+  console.log(responseData.map(r => r.id));
+  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/notification-service/NotificationService.d.ts

@@ -0,0 +1,3 @@
+export default class NotificationService {
+    static createNotification(title: string, message: string, link?: string): void;
+}

package/services/notification-service/NotificationService.js

@@ -0,0 +1,24 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export default class NotificationService {
+  // Create a new chrome notification with link
+  static createNotification(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: Array<string>, currency?: string) => Promise<PriceJson>;

package/services/price-service/coingecko.js

@@ -0,0 +1,37 @@
+// 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 inverseMap: Record<string, string> = {};
+    const idStr = priceIds.join(',');
+    const res = await axios.get(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=${currency}&per_page=1000&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;
+
+      // if (inverseMap[val.id]) {
+      //   priceMap[inverseMap[val.id]] = currentPrice;
+      //   price24hMap[inverseMap[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,14 @@
+import { PriceJson } 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 } from 'rxjs';
+export declare class PriceService {
+    private dbService;
+    private chainService;
+    private priceSubject;
+    private refreshTimeout;
+    constructor(dbService: DatabaseService, chainService: ChainService);
+    getPrice(): Promise<PriceJson>;
+    getPriceSubject(): BehaviorSubject<PriceJson>;
+    refreshPriceData(): void;
+}

package/services/price-service/index.js

@@ -0,0 +1,57 @@
+// 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);
+  constructor(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
+    this.refreshPriceData();
+    this.priceSubject.subscribe(rs => {
+      console.log('Price store', rs);
+    });
+  }
+  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;
+  }
+  refreshPriceData() {
+    clearTimeout(this.refreshTimeout);
+    console.log('Start price interval');
+    const priceIds = Object.values(this.chainService.getAssetRegistry()).map(a => a.priceId).filter(a => a);
+
+    // Update for tokens price
+    getTokenPrice(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 => {
+      console.error('Get Token Price with error: ', e);
+    });
+    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>;
+}

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

@@ -0,0 +1,253 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _isChainEnabled, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import AuthorizeStore from '@subwallet/extension-base/stores/Authorize';
+import { getId } from '@subwallet/extension-base/utils/getId';
+import { accounts } from '@subwallet/ui-keyring/observable/accounts';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { assert } from '@polkadot/util';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+const AUTH_URLS_KEY = 'authUrls';
+export default class AuthRequestHandler {
+  #requestService;
+  #chainService;
+  authorizeStore = new AuthorizeStore();
+  #authRequestsV2 = {};
+  authorizeCached = undefined;
+  authorizeUrlSubject = new Subject();
+  evmChainSubject = new Subject();
+  authSubjectV2 = new BehaviorSubject([]);
+  constructor(requestService, chainService) {
+    this.#requestService = requestService;
+    this.#chainService = chainService;
+  }
+  stripUrl(url) {
+    assert(url && (url.startsWith('http:') || url.startsWith('https:') || url.startsWith('ipfs:') || url.startsWith('ipns:')), `Invalid url ${url}, expected to start with http: or https: or ipfs: or ipns:`);
+    const parts = url.split('/');
+    return parts[2];
+  }
+  getAddressList(value = false) {
+    const addressList = Object.keys(accounts.subject.value);
+    return addressList.reduce((addressList, v) => ({
+      ...addressList,
+      [v]: value
+    }), {});
+  }
+  get numAuthRequestsV2() {
+    return Object.keys(this.#authRequestsV2).length;
+  }
+  get allAuthRequestsV2() {
+    return Object.values(this.#authRequestsV2).map(({
+      id,
+      request,
+      url
+    }) => ({
+      id,
+      request,
+      url
+    }));
+  }
+  updateIconAuthV2(shouldClose) {
+    this.authSubjectV2.next(this.allAuthRequestsV2);
+    this.#requestService.updateIconV2(shouldClose);
+  }
+  setAuthorize(data, callback) {
+    this.authorizeStore.set(AUTH_URLS_KEY, data, () => {
+      this.authorizeCached = data;
+      this.evmChainSubject.next(this.authorizeCached);
+      this.authorizeUrlSubject.next(this.authorizeCached);
+      callback && callback();
+    });
+  }
+  getAuthorize(update) {
+    // This action can be use many by DApp interaction => caching it in memory
+    if (this.authorizeCached) {
+      update(this.authorizeCached);
+    } else {
+      this.authorizeStore.get('authUrls', data => {
+        this.authorizeCached = data;
+        update(this.authorizeCached);
+      });
+    }
+  }
+  getAuthList() {
+    return new Promise((resolve, reject) => {
+      this.getAuthorize(rs => {
+        resolve(rs);
+      });
+    });
+  }
+  authCompleteV2 = (id, resolve, reject) => {
+    const isAllowedMap = this.getAddressList();
+    const complete = (result, cb, accounts) => {
+      const isAllowed = result === true;
+      let isCancelled = false;
+      if (!isAllowed && typeof result === 'object' && result.message === 'Cancelled') {
+        isCancelled = true;
+      }
+      if (accounts && accounts.length) {
+        accounts.forEach(acc => {
+          isAllowedMap[acc] = true;
+        });
+      } else {
+        // eslint-disable-next-line no-return-assign
+        Object.keys(isAllowedMap).forEach(address => isAllowedMap[address] = false);
+      }
+      const {
+        accountAuthType,
+        idStr,
+        request: {
+          allowedAccounts,
+          origin
+        },
+        url
+      } = this.#authRequestsV2[id];
+      if (accountAuthType !== 'both') {
+        const isEvmType = accountAuthType === 'evm';
+        const backupAllowed = [...(allowedAccounts || [])].filter(a => {
+          const isEth = isEthereumAddress(a);
+          return isEvmType ? !isEth : isEth;
+        });
+        backupAllowed.forEach(acc => {
+          isAllowedMap[acc] = true;
+        });
+      }
+      let defaultEvmNetworkKey;
+      if (accountAuthType === 'both' || accountAuthType === 'evm') {
+        const defaultChain = Object.values(this.#chainService.getChainInfoMap()).find(chainInfo => {
+          const chainState = this.#chainService.getChainStateByKey(chainInfo.slug);
+          return _isChainEvmCompatible(chainInfo) && _isChainEnabled(chainState);
+        });
+        if (defaultChain) {
+          defaultEvmNetworkKey = defaultChain.slug;
+        }
+      }
+      this.getAuthorize(value => {
+        let authorizeList = {};
+        if (value) {
+          authorizeList = value;
+        }
+        const existed = authorizeList[this.stripUrl(url)];
+
+        // On cancel don't save anything
+        if (isCancelled) {
+          delete this.#authRequestsV2[id];
+          this.updateIconAuthV2(true);
+          cb();
+          return;
+        }
+        authorizeList[this.stripUrl(url)] = {
+          count: 0,
+          id: idStr,
+          isAllowed,
+          isAllowedMap,
+          origin,
+          url,
+          accountAuthType: existed && existed.accountAuthType !== accountAuthType ? 'both' : accountAuthType,
+          currentEvmNetworkKey: existed ? existed.currentEvmNetworkKey : defaultEvmNetworkKey
+        };
+        this.setAuthorize(authorizeList, () => {
+          cb();
+          delete this.#authRequestsV2[id];
+          this.updateIconAuthV2(true);
+        });
+      });
+    };
+    return {
+      reject: error => {
+        complete(error, () => {
+          reject(error);
+        });
+      },
+      resolve: ({
+        accounts,
+        result
+      }) => {
+        complete(result, () => {
+          resolve(result);
+        }, accounts);
+      }
+    };
+  };
+  async authorizeUrlV2(url, request) {
+    let authList = await this.getAuthList();
+    const accountAuthType = request.accountAuthType || 'substrate';
+    request.accountAuthType = accountAuthType;
+    if (!authList) {
+      authList = {};
+    }
+    const idStr = this.stripUrl(url);
+    // Do not enqueue duplicate authorization requests.
+    const isDuplicate = Object.values(this.#authRequestsV2).some(request => request.idStr === idStr);
+    assert(!isDuplicate, `The source ${url} has a pending authorization request`);
+    const existedAuth = authList[idStr];
+    const existedAccountAuthType = existedAuth === null || existedAuth === void 0 ? void 0 : existedAuth.accountAuthType;
+    const confirmAnotherType = existedAccountAuthType !== 'both' && existedAccountAuthType !== request.accountAuthType;
+    if (request.reConfirm && existedAuth) {
+      request.origin = existedAuth.origin;
+    }
+
+    // Reconfirm if check auth for empty list
+    if (existedAuth) {
+      const inBlackList = existedAuth && !existedAuth.isAllowed;
+      if (inBlackList) {
+        throw new Error(`The source ${url} is not allowed to interact with this extension`);
+      }
+      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));
+      }
+      if (!confirmAnotherType && !request.reConfirm && allowedListByRequestType.length !== 0) {
+        // Prevent appear confirmation popup
+        return false;
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const id = getId();
+      this.#authRequestsV2[id] = {
+        ...this.authCompleteV2(id, resolve, reject),
+        id,
+        idStr,
+        request,
+        url,
+        accountAuthType: accountAuthType
+      };
+      this.updateIconAuthV2();
+      if (Object.keys(this.#authRequestsV2).length < 2) {
+        this.#requestService.popupOpen();
+      }
+    });
+  }
+  getAuthRequestV2(id) {
+    return this.#authRequestsV2[id];
+  }
+  get subscribeEvmChainChange() {
+    return this.evmChainSubject;
+  }
+  get subscribeAuthorizeUrlSubject() {
+    return this.authorizeUrlSubject;
+  }
+  ensureUrlAuthorizedV2(url) {
+    const idStr = this.stripUrl(url);
+    return new Promise((resolve, reject) => {
+      this.getAuthorize(value => {
+        if (!value) {
+          value = {};
+        }
+        const entry = Object.keys(value).includes(idStr);
+        if (!entry) {
+          reject(new Error(`The source ${url} has not been enabled yet`));
+        }
+        const isConnected = value[idStr] && Object.keys(value[idStr].isAllowedMap).some(address => value[idStr].isAllowedMap[address]);
+        if (!isConnected) {
+          reject(new Error(`The source ${url} is not allowed to interact with this extension`));
+        }
+        resolve(true);
+      });
+    });
+  }
+}