@subwallet/extension-base 0.8.3-2 → 1.0.1

package/koni/background/handlers/Tabs.js

@@ -0,0 +1,746 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _AssetType } from '@subwallet/chain-list/types';
+import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
+import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
+import { createSubscription, unsubscribe } from '@subwallet/extension-base/background/handlers/subscriptions';
+import { EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import RequestBytesSign from '@subwallet/extension-base/background/RequestBytesSign';
+import RequestExtrinsicSign from '@subwallet/extension-base/background/RequestExtrinsicSign';
+import { ALL_ACCOUNT_KEY, CRON_GET_API_MAP_STATUS } from '@subwallet/extension-base/constants';
+import { PHISHING_PAGE_REDIRECT } from '@subwallet/extension-base/defaults';
+import { _generateCustomProviderKey } from '@subwallet/extension-base/services/chain-service/utils';
+import { canDerive } from '@subwallet/extension-base/utils';
+import keyring from '@subwallet/ui-keyring';
+import { accounts as accountsObservable } from '@subwallet/ui-keyring/observable/accounts';
+import Web3 from 'web3';
+import { checkIfDenied } from '@polkadot/phishing';
+import { assert, isNumber } from '@polkadot/util';
+function 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];
+}
+function transformAccountsV2(accounts, anyType = false, authInfo, accountAuthType) {
+  const accountSelected = authInfo ? authInfo.isAllowed ? Object.keys(authInfo.isAllowedMap).filter(address => authInfo.isAllowedMap[address]) : [] : [];
+  let authTypeFilter = ({
+    type
+  }) => true;
+  if (accountAuthType === 'substrate') {
+    authTypeFilter = ({
+      type
+    }) => type !== 'ethereum';
+  } else if (accountAuthType === 'evm') {
+    authTypeFilter = ({
+      type
+    }) => type === 'ethereum';
+  }
+  return Object.values(accounts).filter(({
+    json: {
+      meta: {
+        isHidden
+      }
+    }
+  }) => !isHidden).filter(({
+    type
+  }) => anyType ? true : canDerive(type)).filter(authTypeFilter).filter(({
+    json: {
+      address
+    }
+  }) => accountSelected.includes(address)).sort((a, b) => (a.json.meta.whenCreated || 0) - (b.json.meta.whenCreated || 0)).map(({
+    json: {
+      address,
+      meta: {
+        genesisHash,
+        name
+      }
+    },
+    type
+  }) => ({
+    address,
+    genesisHash,
+    name,
+    type
+  }));
+}
+export default class KoniTabs {
+  #koniState;
+  evmEventEmitterMap = {};
+  constructor(koniState) {
+    this.#koniState = koniState;
+  }
+
+  /// Clone from Polkadot.js
+  getSigningPair(address) {
+    const pair = keyring.getPair(address);
+    assert(pair, 'Unable to find keypair');
+    return pair;
+  }
+  bytesSign(url, request) {
+    const address = request.address;
+    const pair = this.getSigningPair(address);
+    return this.#koniState.sign(url, new RequestBytesSign(request), {
+      address,
+      ...pair.meta
+    });
+  }
+  extrinsicSign(url, request) {
+    const address = request.address;
+    const pair = this.getSigningPair(address);
+    return this.#koniState.sign(url, new RequestExtrinsicSign(request), {
+      address,
+      ...pair.meta
+    });
+  }
+  metadataProvide(url, request) {
+    return this.#koniState.injectMetadata(url, request);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  metadataList(url) {
+    return this.#koniState.knownMetadata.map(({
+      genesisHash,
+      specVersion
+    }) => ({
+      genesisHash,
+      specVersion
+    }));
+  }
+  rpcListProviders() {
+    return this.#koniState.rpcListProviders();
+  }
+  rpcSend(request, port) {
+    return this.#koniState.rpcSend(request, port);
+  }
+  rpcStartProvider(key, port) {
+    return this.#koniState.rpcStartProvider(key, port);
+  }
+  async rpcSubscribe(request, id, port) {
+    const innerCb = createSubscription(id, port);
+    const cb = (_error, data) => innerCb(data);
+    const subscriptionId = await this.#koniState.rpcSubscribe(request, cb, port);
+    port.onDisconnect.addListener(() => {
+      unsubscribe(id);
+      withErrorLog(() => this.rpcUnsubscribe({
+        ...request,
+        subscriptionId
+      }, port));
+    });
+    return true;
+  }
+  rpcSubscribeConnected(request, id, port) {
+    const innerCb = createSubscription(id, port);
+    const cb = (_error, data) => innerCb(data);
+    this.#koniState.rpcSubscribeConnected(request, cb, port);
+    port.onDisconnect.addListener(() => {
+      unsubscribe(id);
+    });
+    return Promise.resolve(true);
+  }
+  async rpcUnsubscribe(request, port) {
+    return this.#koniState.rpcUnsubscribe(request, port);
+  }
+  redirectPhishingLanding(phishingWebsite) {
+    const nonFragment = phishingWebsite.split('#')[0];
+    const encodedWebsite = encodeURIComponent(nonFragment);
+    const url = `${chrome.extension.getURL('index.html')}#${PHISHING_PAGE_REDIRECT}/${encodedWebsite}`;
+    chrome.tabs.query({
+      url: nonFragment
+    }, tabs => {
+      tabs.map(({
+        id
+      }) => id).filter(id => isNumber(id)).forEach(id => withErrorLog(() => chrome.tabs.update(id, {
+        url
+      })));
+    });
+  }
+  async redirectIfPhishing(url) {
+    const isInDenyList = await checkIfDenied(url);
+    if (isInDenyList) {
+      this.redirectPhishingLanding(url);
+      return true;
+    }
+    return false;
+  }
+
+  ///
+
+  cancelSubscription(id) {
+    return this.#koniState.cancelSubscription(id);
+  }
+  createUnsubscriptionHandle(id, unsubscribe) {
+    this.#koniState.createUnsubscriptionHandle(id, unsubscribe);
+  }
+  async getAuthInfo(url) {
+    const authList = await this.#koniState.getAuthList();
+    const shortenUrl = stripUrl(url);
+    return authList[shortenUrl];
+  }
+  async accountsListV2(url, {
+    accountAuthType,
+    anyType
+  }) {
+    const authInfo = await this.getAuthInfo(url);
+    return transformAccountsV2(accountsObservable.subject.getValue(), anyType, authInfo, accountAuthType);
+  }
+  accountsSubscribeV2(url, {
+    accountAuthType
+  }, id, port) {
+    const cb = createSubscription(id, port);
+    const subscription = accountsObservable.subject.subscribe(accounts => {
+      this.getAuthInfo(url).then(authInfo => {
+        cb(transformAccountsV2(accounts, false, authInfo, accountAuthType));
+      }).catch(console.error);
+    });
+    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  authorizeV2(url, request) {
+    if (request.accountAuthType === 'evm') {
+      return new Promise((resolve, reject) => {
+        this.#koniState.authorizeUrlV2(url, request).then(resolve).catch(e => {
+          reject(new EvmProviderError(EvmProviderErrorType.USER_REJECTED_REQUEST));
+        });
+      });
+    } else {
+      return this.#koniState.authorizeUrlV2(url, request);
+    }
+  }
+  async getEvmCurrentAccount(url, getAll = false) {
+    return await new Promise(resolve => {
+      this.getAuthInfo(url).then(authInfo => {
+        const allAccounts = accountsObservable.subject.getValue();
+        const accountList = transformAccountsV2(allAccounts, false, authInfo, 'evm').map(a => a.address);
+        let accounts = [];
+        this.#koniState.getCurrentAccount(({
+          address
+        }) => {
+          if (address === ALL_ACCOUNT_KEY || !accountList.includes(address) || getAll) {
+            accounts = accountList;
+          } else if (address && accountList.includes(address)) {
+            accounts = [address];
+          }
+          resolve(accounts);
+        });
+      }).catch(console.error);
+    });
+  }
+  async getEvmState(url) {
+    let currentEvmNetworkKey;
+    if (url) {
+      const authInfo = await this.getAuthInfo(url);
+      currentEvmNetworkKey = authInfo === null || authInfo === void 0 ? void 0 : authInfo.currentEvmNetworkKey;
+    }
+    let currentEvmNetwork = currentEvmNetworkKey ? this.#koniState.getChainInfo(currentEvmNetworkKey) : undefined;
+    if (currentEvmNetworkKey && !this.#koniState.getChainStateByKey(currentEvmNetworkKey).active) {
+      currentEvmNetwork = Object.values(this.#koniState.getChainInfoMap()).find(network => {
+        return network.evmInfo !== null && this.#koniState.getChainStateByKey(network.slug).active;
+      });
+    }
+    if (currentEvmNetwork) {
+      const {
+        evmInfo,
+        slug
+      } = currentEvmNetwork;
+      const evmApi = this.#koniState.getEvmApi(slug);
+      const web3 = evmApi.api;
+      if (web3.currentProvider instanceof Web3.providers.WebsocketProvider) {
+        if (!web3.currentProvider.connected) {
+          console.log(`[Web3] ${slug} is disconnected, trying to connect...`);
+          this.#koniState.refreshWeb3Api(slug);
+          const poll = resolve => {
+            if (web3.currentProvider.connected) {
+              console.log(`Network [${slug}] is connected.`);
+              resolve(true);
+            } else {
+              console.log(`Connecting to network [${slug}]`);
+              setTimeout(() => poll(resolve), 400);
+            }
+          };
+          await new Promise(poll);
+        }
+      }
+      return {
+        networkKey: slug,
+        chainId: `0x${((evmInfo === null || evmInfo === void 0 ? void 0 : evmInfo.evmChainId) || 0).toString(16)}`,
+        web3
+      };
+    } else {
+      return {};
+    }
+  }
+  async getEvmPermission(url, id) {
+    const accounts = await this.getEvmCurrentAccount(url, true);
+    return [{
+      id: id,
+      invoker: url,
+      parentCapability: 'eth_accounts',
+      caveats: [{
+        type: 'restrictReturnedAccounts',
+        value: accounts
+      }],
+      date: new Date().getTime()
+    }];
+  }
+  async switchEvmChain(id, url, {
+    params
+  }) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const chainId = params[0].chainId;
+    const evmState = await this.getEvmState(url);
+    if (evmState.chainId === chainId) {
+      return null;
+    }
+    const [networkKey] = this.#koniState.findNetworkKeyByChainId(parseInt(chainId, 16));
+    if (networkKey) {
+      await this.#koniState.switchEvmNetworkByUrl(stripUrl(url), networkKey);
+    } else {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, `Not found chainId ${chainId} in wallet`);
+    }
+    return null;
+  }
+  async addEvmToken(id, url, {
+    params
+  }) {
+    var _input$type, _input$options, _input$options2;
+    const input = params;
+    const _tokenType = (input === null || input === void 0 ? void 0 : (_input$type = input.type) === null || _input$type === void 0 ? void 0 : _input$type.toLowerCase()) || '';
+    if (_tokenType !== 'erc20' && _tokenType !== 'erc721') {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, `Assets type ${_tokenType} is not supported`);
+    }
+    if (!(input !== null && input !== void 0 && (_input$options = input.options) !== null && _input$options !== void 0 && _input$options.address) || !(input !== null && input !== void 0 && (_input$options2 = input.options) !== null && _input$options2 !== void 0 && _input$options2.symbol)) {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Assets params require address and symbol');
+    }
+    const evmState = await this.getEvmState(url);
+    const chain = evmState.networkKey;
+    if (!chain) {
+      throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, 'Current chain is not available');
+    }
+    const tokenType = _tokenType === 'erc20' ? _AssetType.ERC20 : _AssetType.ERC721;
+    const validate = await this.#koniState.validateCustomAsset({
+      type: tokenType,
+      contractAddress: input.options.address,
+      originChain: chain
+    });
+    if (validate.isExist) {
+      throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, 'Current token is existed');
+    } else if (validate.contractError) {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Contract address is invalid');
+    }
+    const tokenInfo = {
+      type: tokenType,
+      name: validate.name,
+      contractAddress: input.options.address,
+      symbol: validate.symbol,
+      decimals: validate.decimals,
+      originChain: chain
+    };
+    return await this.#koniState.addTokenConfirm(id, url, tokenInfo);
+  }
+  async addEvmChain(id, url, {
+    params
+  }) {
+    const input = params;
+    if (input && input.length > 0) {
+      const {
+        blockExplorerUrls,
+        chainId,
+        chainName,
+        rpcUrls
+      } = input[0];
+      if (chainId) {
+        const chainIdNum = parseInt(chainId, 16);
+        const [networkKey] = this.#koniState.findNetworkKeyByChainId(chainIdNum);
+        if (networkKey) {
+          return await this.switchEvmChain(id, url, {
+            method: 'wallet_switchEthereumChain',
+            params: [{
+              chainId
+            }]
+          });
+        }
+        if (rpcUrls && chainName) {
+          const filteredUrls = rpcUrls.filter(targetString => {
+            let url;
+            try {
+              url = new URL(targetString);
+            } catch (_) {
+              return false;
+            }
+            return url.protocol === 'http:' || url.protocol === 'https:';
+          });
+          if (!filteredUrls.length) {
+            throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, 'Currently HTTP provider for EVM network');
+          }
+          const provider = filteredUrls[0];
+          const chainInfo = await this.#koniState.validateCustomChain(provider);
+          if (!chainInfo.success) {
+            throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Invalid provider');
+          }
+          const newProviderKey = _generateCustomProviderKey(0);
+          return await this.#koniState.addNetworkConfirm(id, url, {
+            mode: 'insert',
+            chainSpec: {
+              evmChainId: chainInfo.evmChainId,
+              decimals: chainInfo.decimals,
+              existentialDeposit: chainInfo.existentialDeposit,
+              genesisHash: chainInfo.genesisHash,
+              paraId: chainInfo.paraId,
+              addressPrefix: chainInfo.addressPrefix ? parseInt(chainInfo.addressPrefix) : 0
+            },
+            chainEditInfo: {
+              blockExplorer: blockExplorerUrls === null || blockExplorerUrls === void 0 ? void 0 : blockExplorerUrls[0],
+              slug: '',
+              currentProvider: newProviderKey,
+              providers: {
+                [newProviderKey]: provider
+              },
+              symbol: chainInfo.symbol,
+              chainType: 'EVM',
+              name: chainInfo.name
+            }
+          });
+        }
+      }
+    }
+    return null;
+  }
+  async getEvmCurrentChainId(url) {
+    const evmState = await this.getEvmState(url);
+    return evmState.chainId || '0x0';
+  }
+  async evmSubscribeEvents(url, id, port) {
+    // This method will be called after DApp request connect to extension
+    const cb = createSubscription(id, port);
+    let isConnected = false;
+    const emitEvent = (eventName, payload) => {
+      // eslint-disable-next-line node/no-callback-literal
+      cb({
+        type: eventName,
+        payload: payload
+      });
+    };
+
+    // Detect accounts changed
+    let currentAccountList = await this.getEvmCurrentAccount(url);
+    const onCurrentAccountChanged = async () => {
+      const newAccountList = await this.getEvmCurrentAccount(url);
+
+      // Compare to void looping reload
+      if (JSON.stringify(currentAccountList) !== JSON.stringify(newAccountList)) {
+        // eslint-disable-next-line node/no-callback-literal
+        emitEvent('accountsChanged', newAccountList);
+        currentAccountList = newAccountList;
+      }
+    };
+    const accountListSubscription = this.#koniState.subscribeCurrentAccount().subscribe(() => {
+      onCurrentAccountChanged().catch(console.error);
+    });
+
+    // Detect network chain
+    const evmState = await this.getEvmState(url);
+    let currentChainId = evmState.chainId;
+    const _onAuthChanged = async () => {
+      // Detect network
+      const {
+        chainId
+      } = await this.getEvmState(url);
+      if (chainId !== currentChainId) {
+        emitEvent('chainChanged', chainId);
+        currentChainId = chainId;
+      }
+
+      // Detect account
+      const newAccountList = await this.getEvmCurrentAccount(url);
+
+      // Compare to void looping reload
+      if (JSON.stringify(currentAccountList) !== JSON.stringify(newAccountList)) {
+        // eslint-disable-next-line node/no-callback-literal
+        emitEvent('accountsChanged', newAccountList);
+        currentAccountList = newAccountList;
+      }
+    };
+    const authUrlSubscription = this.#koniState.subscribeEvmChainChange().subscribe(rs => {
+      _onAuthChanged().catch(console.error);
+    });
+
+    // Detect network connection
+    const networkCheck = () => {
+      this.getEvmState(url).then(evmState => {
+        var _evmState$web;
+        (_evmState$web = evmState.web3) === null || _evmState$web === void 0 ? void 0 : _evmState$web.eth.net.isListening().then(connecting => {
+          if (connecting && !isConnected) {
+            emitEvent('connect', {
+              chainId: evmState.chainId
+            });
+          } else if (!connecting && isConnected) {
+            emitEvent('disconnect', new EvmProviderError(EvmProviderErrorType.CHAIN_DISCONNECTED));
+          }
+          isConnected = connecting;
+        }).catch(console.error);
+      }).catch(console.error);
+    };
+    const networkCheckInterval = setInterval(networkCheck, CRON_GET_API_MAP_STATUS);
+    const provider = await this.getEvmProvider(url);
+    const eventMap = {};
+    eventMap.data = ({
+      method,
+      params
+    }) => {
+      emitEvent('message', {
+        type: method,
+        data: params
+      });
+    };
+    eventMap.error = rs => {
+      emitEvent('error', rs);
+    };
+    Object.entries(eventMap).forEach(([event, callback]) => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      (provider === null || provider === void 0 ? void 0 : provider.on) && (provider === null || provider === void 0 ? void 0 : provider.on(event, callback));
+    });
+
+    // Add event emitter
+    if (!this.evmEventEmitterMap[url]) {
+      this.evmEventEmitterMap[url] = {};
+    }
+    this.evmEventEmitterMap[url][id] = emitEvent;
+    this.createUnsubscriptionHandle(id, () => {
+      if (this.evmEventEmitterMap[url][id]) {
+        delete this.evmEventEmitterMap[url][id];
+      }
+      Object.entries(eventMap).forEach(([event, callback]) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        (provider === null || provider === void 0 ? void 0 : provider.removeListener) && (provider === null || provider === void 0 ? void 0 : provider.removeListener(event, callback));
+      });
+      accountListSubscription.unsubscribe();
+      authUrlSubscription.unsubscribe();
+      clearInterval(networkCheckInterval);
+    });
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  checkAndHandleProviderStatus(provider) {
+    if ((!provider || !(provider !== null && provider !== void 0 && provider.connected)) && provider !== null && provider !== void 0 && provider.supportsSubscriptions()) {
+      // excludes HttpProvider
+      Object.values(this.evmEventEmitterMap).forEach(m => {
+        Object.values(m).forEach(emitter => {
+          emitter('disconnect', new EvmProviderError(EvmProviderErrorType.CHAIN_DISCONNECTED));
+        });
+      });
+      throw new EvmProviderError(EvmProviderErrorType.CHAIN_DISCONNECTED);
+    }
+  }
+  async getEvmProvider(url) {
+    var _evmState$web2;
+    const evmState = await this.getEvmState(url);
+    let provider = (_evmState$web2 = evmState.web3) === null || _evmState$web2 === void 0 ? void 0 : _evmState$web2.currentProvider;
+    if (!provider) {
+      var _evmState$web3;
+      await this.getEvmCurrentChainId(url);
+      provider = (_evmState$web3 = evmState.web3) === null || _evmState$web3 === void 0 ? void 0 : _evmState$web3.currentProvider;
+    }
+    return provider;
+  }
+  async performWeb3Method(id, url, {
+    method,
+    params
+  }, callback) {
+    const provider = await this.getEvmProvider(url);
+    this.checkAndHandleProviderStatus(provider);
+    return new Promise((resolve, reject) => {
+      provider === null || provider === void 0 ? void 0 : provider.send({
+        jsonrpc: '2.0',
+        method: method,
+        params: params,
+        id
+      }, (error, result) => {
+        const err = (result === null || result === void 0 ? void 0 : result.error) || error;
+        if (err) {
+          reject(err);
+        } else {
+          const rs = result === null || result === void 0 ? void 0 : result.result;
+          callback && callback(rs);
+          resolve(rs);
+        }
+      });
+    });
+  }
+  async canUseAccount(address, url) {
+    const allowedAccounts = await this.getEvmCurrentAccount(url, true);
+    return !!allowedAccounts.find(acc => acc.toLowerCase() === address.toLowerCase());
+  }
+  async evmSign(id, url, {
+    method,
+    params
+  }) {
+    const allowedAccounts = await this.getEvmCurrentAccount(url, true);
+    const signResult = await this.#koniState.evmSign(id, url, method, params, allowedAccounts);
+    if (signResult) {
+      return signResult;
+    } else {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Have something wrong to sign message');
+    }
+  }
+  async evmSendTransaction(id, url, {
+    params
+  }) {
+    const transactionParams = params[0];
+    const canUseAccount = transactionParams.from && this.canUseAccount(transactionParams.from, url);
+    const evmState = await this.getEvmState(url);
+    const networkKey = evmState.networkKey;
+    if (!canUseAccount) {
+      throw new Error('Account ' + transactionParams.from + ' not in allowed list');
+    }
+    if (!networkKey) {
+      throw new Error('Empty current network key');
+    }
+    const allowedAccounts = await this.getEvmCurrentAccount(url, true);
+    const transactionHash = await this.#koniState.evmSendTransaction(id, url, networkKey, allowedAccounts, transactionParams);
+    if (!transactionHash) {
+      throw new EvmProviderError(EvmProviderErrorType.USER_REJECTED_REQUEST);
+    }
+    return transactionHash;
+  }
+  async handleEvmRequest(id, url, request) {
+    const {
+      method
+    } = request;
+    console.log('method: ' + method);
+    try {
+      switch (method) {
+        case 'eth_chainId':
+          return await this.getEvmCurrentChainId(url);
+        case 'net_version':
+          return parseInt(await this.getEvmCurrentChainId(url), 16);
+        case 'eth_accounts':
+          return await this.getEvmCurrentAccount(url);
+        case 'eth_sendTransaction':
+          return await this.evmSendTransaction(id, url, request);
+        case 'eth_sign':
+          return await this.evmSign(id, url, request);
+        case 'personal_sign':
+          return await this.evmSign(id, url, request);
+        case 'eth_signTypedData':
+          return await this.evmSign(id, url, request);
+        case 'eth_signTypedData_v1':
+          return await this.evmSign(id, url, request);
+        case 'eth_signTypedData_v3':
+          return await this.evmSign(id, url, request);
+        case 'eth_signTypedData_v4':
+          return await this.evmSign(id, url, request);
+        case 'wallet_requestPermissions':
+          await this.authorizeV2(url, {
+            origin: '',
+            accountAuthType: 'evm',
+            reConfirm: true
+          });
+          return await this.getEvmPermission(url, id);
+        case 'wallet_getPermissions':
+          return await this.getEvmPermission(url, id);
+        case 'wallet_addEthereumChain':
+          return await this.addEvmChain(id, url, request);
+        case 'wallet_switchEthereumChain':
+          return await this.switchEvmChain(id, url, request);
+        case 'wallet_watchAsset':
+          return await this.addEvmToken(id, url, request);
+        default:
+          return this.performWeb3Method(id, url, request);
+      }
+    } catch (e) {
+      // @ts-ignore
+      if (e.code) {
+        throw e;
+      } else {
+        // @ts-ignore
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, e.message);
+      }
+    }
+  }
+  async handleEvmSend(id, url, port, request) {
+    var _evmState$web4;
+    const cb = createSubscription(id, port);
+    const evmState = await this.getEvmState(url);
+    const provider = (_evmState$web4 = evmState.web3) === null || _evmState$web4 === void 0 ? void 0 : _evmState$web4.currentProvider;
+    this.checkAndHandleProviderStatus(provider);
+    provider.send(request, (error, result) => {
+      // eslint-disable-next-line node/no-callback-literal
+      cb({
+        error,
+        result
+      });
+      this.cancelSubscription(id);
+    });
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  isEvmPublicRequest(type, request) {
+    if (type === 'evm(request)' && ['eth_chainId', 'net_version'].includes(request === null || request === void 0 ? void 0 : request.method)) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  async handle(id, type, request, url, port) {
+    if (type === 'pub(phishing.redirectIfDenied)') {
+      return this.redirectIfPhishing(url);
+    }
+    if (type !== 'pub(authorize.tabV2)' && !this.isEvmPublicRequest(type, request)) {
+      await this.#koniState.ensureUrlAuthorizedV2(url).catch(e => {
+        if (type.startsWith('evm')) {
+          throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, e.message);
+        } else {
+          throw e;
+        }
+      });
+    }
+    switch (type) {
+      /// Clone from PolkadotJs
+      case 'pub(bytes.sign)':
+        return this.bytesSign(url, request);
+      case 'pub(extrinsic.sign)':
+        return this.extrinsicSign(url, request);
+      case 'pub(metadata.list)':
+        return this.metadataList(url);
+      case 'pub(metadata.provide)':
+        return this.metadataProvide(url, request);
+      case 'pub(rpc.listProviders)':
+        return this.rpcListProviders();
+      case 'pub(rpc.send)':
+        return this.rpcSend(request, port);
+      case 'pub(rpc.startProvider)':
+        return this.rpcStartProvider(request, port);
+      case 'pub(rpc.subscribe)':
+        return this.rpcSubscribe(request, id, port);
+      case 'pub(rpc.subscribeConnected)':
+        return this.rpcSubscribeConnected(request, id, port);
+      case 'pub(rpc.unsubscribe)':
+        return this.rpcUnsubscribe(request, port);
+
+      ///
+      case 'pub(authorize.tabV2)':
+        return this.authorizeV2(url, request);
+      case 'pub(accounts.listV2)':
+        return this.accountsListV2(url, request);
+      case 'pub(accounts.subscribeV2)':
+        return this.accountsSubscribeV2(url, request, id, port);
+      case 'evm(events.subscribe)':
+        return await this.evmSubscribeEvents(url, id, port);
+      case 'evm(request)':
+        return await this.handleEvmRequest(id, url, request);
+      case 'evm(provider.send)':
+        return await this.handleEvmSend(id, url, port, request);
+      default:
+        throw new Error(`Unable to handle message of type ${type}`);
+    }
+  }
+}