@subwallet/extension-base 1.0.1 → 1.0.2-1

package/services/request-service/index.js

@@ -96,6 +96,9 @@ export default class RequestService {
   getAuthRequestV2(id) {
     return this.#authRequestHandler.getAuthRequestV2(id);
   }
+  getDAppChainInfo(options) {
+    return this.#authRequestHandler.getDAppChainInfo(options);
+  }
   get subscribeEvmChainChange() {
     return this.#authRequestHandler.subscribeEvmChainChange;
   }

package/services/storage-service/DatabaseService.js

@@ -157,7 +157,7 @@ export default class DatabaseService {
     });
   }
   handleNftTransfer(chain, addresses, nftItem) {
-    return this.stores.nft.deleteNftByAddresses(chain, addresses, nftItem);
+    return this.stores.nft.deleteNftItem(chain, addresses, nftItem);
   }
   removeNfts(chain, address, collectionId, nftIds) {
     this.logger.log(`Remove NFTs [${nftIds.join(', ')}]`);

package/services/storage-service/databases/index.js

@@ -4,7 +4,7 @@
 import Dexie from 'dexie';
 const DEFAULT_DATABASE = 'SubWalletDB_v2';
 export default class KoniDatabase extends Dexie {
-  constructor(name = DEFAULT_DATABASE, schemaVersion = 9) {
+  constructor(name = DEFAULT_DATABASE, schemaVersion = 10) {
     super(name);
     this.schemaVersion = schemaVersion;
     this.conditionalVersion(1, {

package/services/storage-service/db-stores/BaseStoreWithAddressAndChain.d.ts

@@ -2,6 +2,6 @@ import { DefaultDocWithAddressAndChain } from '@subwallet/extension-base/service
 import BaseStore from '@subwallet/extension-base/services/storage-service/db-stores/BaseStore';
 export default class BaseStoreWithAddressAndChain<T extends DefaultDocWithAddressAndChain> extends BaseStore<T> {
     convertToJsonObject(items: T[]): Record<string, T>;
-    removeAllByAddress(address: string, chain?: string): import("dexie").PromiseExtended<number>;
+    removeAllByAddress(address: string): import("dexie").PromiseExtended<number>;
     getDataByAddressAsObject(address: string): Promise<Record<string, T>>;
 }

package/services/storage-service/db-stores/BaseStoreWithAddressAndChain.js

@@ -9,14 +9,8 @@ export default class BaseStoreWithAddressAndChain extends BaseStore {
       [v.chain]: v
     }), {});
   }
-  removeAllByAddress(address, chain) {
-    const conditions = {
-      address
-    };
-    if (chain) {
-      conditions.chain = chain;
-    }
-    return this.table.where(conditions).delete();
+  removeAllByAddress(address) {
+    return this.table.where('address').equalsIgnoreCase(address).delete();
   }
   async getDataByAddressAsObject(address) {
     const data = await this.table.where('address').equals(address).toArray();

package/services/storage-service/db-stores/Nft.d.ts

@@ -6,7 +6,8 @@ export default class NftStore extends BaseStoreWithAddressAndChain<INft> {
     subscribeNft(addresses: string[], chainList?: string[]): import("dexie").Observable<INft[]>;
     deleteRemovedNftsFromCollection(chainHash: string, address: string, collection?: string, nftIds?: string[]): void | import("dexie").PromiseExtended<number>;
     deleteNftsFromRemovedCollection(chain: string, address: string, collectionIds: string[]): import("dexie").Collection<INft, unknown>;
-    deleteNftByAddresses(chain: string, addresses: string[], nftItem: NftItem): import("dexie").PromiseExtended<number>;
+    deleteNftByAddress(addresses: string[]): import("dexie").PromiseExtended<number>;
+    deleteNftItem(chain: string, addresses: string[], nftItem: NftItem): import("dexie").PromiseExtended<number>;
     deleteNftsByCollection(chain: string, collectionId: string): import("dexie").PromiseExtended<number>;
     removeNfts(chain: string, address: string, collectionId: string, nftIds: string[]): import("dexie").PromiseExtended<number>;
 }

package/services/storage-service/db-stores/Nft.js

@@ -34,7 +34,10 @@ export default class NftStore extends BaseStoreWithAddressAndChain {
       chain
     }).and(nft => !collectionIds.some(item => item === nft.collectionId));
   }
-  deleteNftByAddresses(chain, addresses, nftItem) {
+  deleteNftByAddress(addresses) {
+    return this.table.where('address').anyOfIgnoreCase(addresses).delete();
+  }
+  deleteNftItem(chain, addresses, nftItem) {
     return this.table.where('address').anyOfIgnoreCase(addresses).filter(storedItem => storedItem.chain === chain && storedItem.collectionId === nftItem.collectionId && storedItem.id === nftItem.id).delete();
   }
   deleteNftsByCollection(chain, collectionId) {

package/services/storage-service/db-stores/Transaction.js

@@ -29,13 +29,16 @@ export default class TransactionStore extends BaseStoreWithAddressAndChain {
   }
   async bulkUpsert(records) {
     await this.table.bulkPut(records);
-    await Promise.all(records.map(record => {
-      return this.table.where({
-        chain: record.chain,
-        address: record.address,
-        extrinsicHash: record.extrinsicHash
-      }).filter(item => item.origin === 'app' && record.origin !== 'app').delete();
-    }));
+
+    // await Promise.all(records.map((record) => {
+    //   return this.table.where({
+    //     chain: record.chain,
+    //     address: record.address,
+    //     extrinsicHash: record.extrinsicHash
+    //   }).filter((item) => (item.origin === 'app' && record.origin !== 'app'))
+    //     .delete();
+    // }));
+
     return true;
   }
 }

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

@@ -0,0 +1,20 @@
+import { IMultiChainBalance } from '@subwallet/extension-base/services/subscan-service/types';
+export declare class SubscanService {
+    private limitRate;
+    private intervalCheck;
+    private maxRetry;
+    private requestMap;
+    private nextId;
+    private isRunning;
+    private getId;
+    constructor(options?: {
+        limitRate?: number;
+        intervalCheck?: number;
+        maxRetry?: number;
+    });
+    private getApiUrl;
+    private postRequest;
+    private addRequest;
+    private process;
+    getMultiChainBalance(address: string): Promise<IMultiChainBalance[]>;
+}

package/services/subscan-service/index.js

@@ -0,0 +1,99 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import SUBSCAN_CHAIN_MAP from '@subwallet/extension-base/services/subscan-service/subscan-chain-map';
+import fetch from 'cross-fetch';
+export class SubscanService {
+  limitRate = 2; // limit per interval check
+  intervalCheck = 1000; // interval check in ms
+  maxRetry = 9; // interval check in ms
+  requestMap = {};
+  nextId = 0;
+  isRunning = false;
+  getId() {
+    return this.nextId++;
+  }
+  constructor(options) {
+    this.limitRate = (options === null || options === void 0 ? void 0 : options.limitRate) || this.limitRate;
+    this.intervalCheck = (options === null || options === void 0 ? void 0 : options.intervalCheck) || this.intervalCheck;
+    this.maxRetry = (options === null || options === void 0 ? void 0 : options.maxRetry) || this.maxRetry;
+  }
+  getApiUrl(chain, path) {
+    const subscanChain = SUBSCAN_CHAIN_MAP[chain];
+    if (!subscanChain) {
+      throw new SWError('NOT_SUPPORTED', 'Chain is not supported');
+    }
+    return `https://${chain}.api.subscan.io/${path}`;
+  }
+  postRequest(url, body) {
+    return fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+  }
+  addRequest(run) {
+    const newId = this.getId();
+    return new Promise((resolve, reject) => {
+      this.requestMap[newId] = {
+        id: newId,
+        status: 'pending',
+        retry: -1,
+        run,
+        resolve,
+        reject
+      };
+      if (!this.isRunning) {
+        this.process();
+      }
+    });
+  }
+  process() {
+    this.isRunning = true;
+    const maxRetry = this.maxRetry;
+    const interval = setInterval(() => {
+      const remainingRequests = Object.values(this.requestMap);
+      if (remainingRequests.length === 0) {
+        this.isRunning = false;
+        clearInterval(interval);
+        return;
+      }
+
+      // Get first this.limit requests base on id
+      const requests = remainingRequests.filter(request => request.status !== 'running').sort((a, b) => a.id - b.id).slice(0, this.limitRate);
+
+      // Start requests
+      requests.forEach(request => {
+        request.status = 'running';
+        request.run().then(rs => {
+          request.resolve(rs);
+        }).catch(e => {
+          if (request.retry < maxRetry) {
+            request.status = 'pending';
+            request.retry++;
+          } else {
+            // Reject request
+            request.reject(new SWError('MAX_RETRY', String(e)));
+          }
+        });
+      });
+    }, this.intervalCheck);
+  }
+
+  // Implement Subscan API
+  getMultiChainBalance(address) {
+    return this.addRequest(async () => {
+      const rs = await this.postRequest(this.getApiUrl('polkadot', 'api/scan/multiChain/account'), {
+        address
+      });
+      if (rs.status !== 200) {
+        throw new SWError('SubscanService.getMultiChainBalance', await rs.text());
+      }
+      const jsonData = await rs.json();
+      return jsonData.data;
+    });
+  }
+}

package/services/subscan-service/subscan-chain-map.d.ts

@@ -0,0 +1,5 @@
+declare const SUBSCAN_CHAIN_MAP: Record<string, string>;
+export declare const SUBSCAN_CHAIN_MAP_REVERSE: {
+    [k: string]: string;
+};
+export default SUBSCAN_CHAIN_MAP;

package/services/subscan-service/subscan-chain-map.js

@@ -0,0 +1,63 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const SUBSCAN_CHAIN_MAP = {
+  polkadot: 'polkadot',
+  kusama: 'kusama',
+  moonbeam: 'moonbeam',
+  acala: 'acala',
+  astar: 'astar',
+  shiden: 'shiden',
+  shibuya: 'shibuya',
+  westend: 'westend',
+  moonbase: 'moonbase',
+  moonriver: 'moonriver',
+  turing: 'turing',
+  bifrost_testnet: 'bifrost-testnet',
+  calamari: 'calamari',
+  statemint: 'statemint',
+  pioneer: 'pioneer',
+  parallel: 'parallel',
+  clover: 'clover',
+  hydradx_main: 'hydradx',
+  edgeware: 'edgeware',
+  centrifuge: 'centrifuge',
+  interlay: 'interlay',
+  nodle: 'nodle',
+  darwinia: 'darwinia',
+  polkadex: 'polkadex',
+  aleph: 'alephzero',
+  dolphin: 'dolphin',
+  efinity: 'efinity',
+  composableFinance: 'composable',
+  phala: 'phala',
+  crust: 'crust',
+  statemine: 'statemine',
+  karura: 'karura',
+  khala: 'khala',
+  kilt: 'spiritnet',
+  basilisk: 'basilisk',
+  altair: 'altair',
+  heiko: 'parallel-heiko',
+  kintsugi: 'kintsugi',
+  picasso: 'picasso',
+  quartz: 'quartz',
+  unique_network: 'unique',
+  genshiro: 'genshiro',
+  zeitgeist: 'zeitgeist',
+  sakura: 'sakura',
+  shadow: 'shadow',
+  robonomics: 'robonomics',
+  integritee: 'integritee',
+  acala_testnet: 'acala-testnet',
+  mangatax: 'mangatax',
+  encointer: 'encointer',
+  subspace_gemini_2a: 'subspace',
+  origintrail: 'origintrail',
+  bajun: 'bajun',
+  snow: 'snow',
+  kilt_peregrine: 'kilt-testnet',
+  polymesh: 'polymesh'
+};
+export const SUBSCAN_CHAIN_MAP_REVERSE = Object.fromEntries(Object.entries(SUBSCAN_CHAIN_MAP).map(([k, v]) => [v, k]));
+export default SUBSCAN_CHAIN_MAP;

package/services/subscan-service/types.d.ts

@@ -0,0 +1,27 @@
+export interface SubscanRequest<T> {
+    id: number;
+    retry: number;
+    status: 'pending' | 'running';
+    run: () => Promise<any>;
+    resolve: (value: any) => T;
+    reject: (error?: any) => void;
+}
+export interface SubscanResponse<T = any> {
+    code: number;
+    message: string;
+    data: T;
+}
+export interface IMultiChainBalance {
+    network: string;
+    symbol: string;
+    decimal: number;
+    price: string;
+    category: string;
+    balance: string;
+    locked: string;
+    reserved: string;
+    bonded: string;
+    unbonding: string;
+    democracy_lock: string;
+    election_lock: string;
+}

package/services/subscan-service/types.js

@@ -0,0 +1 @@
+export {};

package/services/transaction-service/event-parser/index.d.ts

@@ -1,5 +1,5 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
 import { EventRecord } from '@polkadot/types/interfaces';
-export declare function parseXcmEventLogs(historyItem: TransactionHistoryItem, eventLogs: EventRecord[], chain: string, sendingTokenInfo: _ChainAsset, chainInfo: _ChainInfo): void;
-export declare function parseTransferEventLogs(historyItem: TransactionHistoryItem, eventLogs: EventRecord[], chain: string, sendingTokenInfo: _ChainAsset, chainInfo: _ChainInfo): void;
+export declare function parseXcmEventLogs(historyItem: Partial<TransactionHistoryItem>, eventLogs: EventRecord[], chain: string, sendingTokenInfo: _ChainAsset, chainInfo: _ChainInfo): void;
+export declare function parseTransferEventLogs(historyItem: Partial<TransactionHistoryItem>, eventLogs: EventRecord[], chain: string, sendingTokenInfo: _ChainAsset, chainInfo: _ChainInfo): void;

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

@@ -1,6 +1,7 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BalanceService } from '@subwallet/extension-base/services/balance-service';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { EventService } from '@subwallet/extension-base/services/event-service';
 import { HistoryService } from '@subwallet/extension-base/services/history-service';
 import NotificationService from '@subwallet/extension-base/services/notification-service/NotificationService';
 import RequestService from '@subwallet/extension-base/services/request-service';
@@ -11,6 +12,7 @@ import { TransactionConfig } from 'web3-core';
 import { HexString } from '@polkadot/util/types';
 export default class TransactionService {
     private readonly chainService;
+    private readonly eventService;
     private readonly databaseService;
     private readonly requestService;
     private readonly balanceService;
@@ -18,7 +20,7 @@ export default class TransactionService {
     private readonly notificationService;
     private readonly transactionSubject;
     private get transactions();
-    constructor(chainService: ChainService, requestService: RequestService, balanceService: BalanceService, historyService: HistoryService, notificationService: NotificationService, databaseService: DatabaseService);
+    constructor(chainService: ChainService, eventService: EventService, requestService: RequestService, balanceService: BalanceService, historyService: HistoryService, notificationService: NotificationService, databaseService: DatabaseService);
     private get allTransactions();
     private get processingTransactions();
     getTransaction(id: string): SWTransaction;
@@ -33,7 +35,7 @@ export default class TransactionService {
     private removeTransaction;
     private updateTransaction;
     private getTransactionLink;
-    private transactionToHistory;
+    private transactionToHistories;
     private onHasTransactionHash;
     private handlePostProcessing;
     private onSuccess;

package/services/transaction-service/index.js

@@ -24,8 +24,9 @@ export default class TransactionService {
   get transactions() {
     return this.transactionSubject.getValue();
   }
-  constructor(chainService, requestService, balanceService, historyService, notificationService, databaseService) {
+  constructor(chainService, eventService, requestService, balanceService, historyService, notificationService, databaseService) {
     this.chainService = chainService;
+    this.eventService = eventService;
     this.requestService = requestService;
     this.balanceService = balanceService;
     this.historyService = historyService;
@@ -265,9 +266,10 @@ export default class TransactionService {
     const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
     return getTransactionLink(chainInfo, transaction.extrinsicHash);
   }
-  transactionToHistory(id, eventLogs) {
+  transactionToHistories(id, eventLogs) {
     const transaction = this.getTransaction(id);
     const historyItem = {
+      origin: 'app',
       chain: transaction.chain,
       direction: TransactionDirection.SEND,
       type: transaction.extrinsicType,
@@ -280,8 +282,8 @@ export default class TransactionService {
       time: transaction.createdAt.getTime(),
       fee: transaction.estimateFee,
       blockNumber: 0,
-      // TODO: to be added later
-      blockHash: '' // TODO: to be added later
+      // Will be added in next step
+      blockHash: '' // Will be added in next step
     };
 
     const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
@@ -330,6 +332,12 @@ export default class TransactionService {
             decimals: sendingTokenInfo.decimals || 0,
             symbol: sendingTokenInfo.symbol
           };
+
+          // @ts-ignore
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          historyItem.additionalInfo = {
+            destinationChain: (inputData === null || inputData === void 0 ? void 0 : inputData.destinationNetworkKey) || ''
+          };
           eventLogs && parseXcmEventLogs(historyItem, eventLogs, transaction.chain, sendingTokenInfo, chainInfo);
         }
         break;
@@ -396,15 +404,41 @@ export default class TransactionService {
         {
           const data = parseTransactionData(transaction.data);
           historyItem.to = data.validatorAddress || '';
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.unstakingInfo.claimable || '0'
+          };
+          break;
+        }
+      case ExtrinsicType.STAKING_CANCEL_UNSTAKE:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.selectedUnstaking.claimable || '0'
+          };
+          break;
         }
-        break;
       case ExtrinsicType.EVM_EXECUTE:
         // Todo: Update historyItem.to
         break;
       case ExtrinsicType.UNKNOWN:
         break;
     }
-    return historyItem;
+    try {
+      // Return one more history record if transaction send to account in the wallets
+      const toAccount = (historyItem === null || historyItem === void 0 ? void 0 : historyItem.to) && keyring.getAccount(historyItem.to);
+      if (toAccount) {
+        return [historyItem, {
+          ...historyItem,
+          address: historyItem.to,
+          direction: TransactionDirection.RECEIVED
+        }];
+      }
+    } catch (e) {
+      console.warn(e);
+    }
+    return [historyItem];
   }
   onHasTransactionHash({
     eventLogs,
@@ -416,7 +450,7 @@ export default class TransactionService {
       extrinsicHash,
       status: ExtrinsicStatus.PROCESSING
     });
-    this.historyService.insertHistory(this.transactionToHistory(id, eventLogs)).catch(console.error);
+    this.historyService.insertHistories(this.transactionToHistories(id, eventLogs)).catch(console.error);
     console.log(`Transaction "${id}" is submitted with hash ${extrinsicHash || ''}`);
   }
   handlePostProcessing(id) {
@@ -448,7 +482,7 @@ export default class TransactionService {
     console.log('Transaction completed', id, transaction.extrinsicHash);
 
     // Write success transaction history
-    this.historyService.updateHistory(transaction.chain, transaction.extrinsicHash, {
+    this.historyService.updateHistories(transaction.chain, transaction.extrinsicHash, {
       status: ExtrinsicStatus.SUCCESS,
       blockNumber: blockNumber || 0,
       blockHash: blockHash || ''
@@ -462,6 +496,7 @@ export default class TransactionService {
       },
       notifyViaBrowser: true
     });
+    this.eventService.emit('transaction.done', transaction);
   }
   onFailed({
     blockHash,
@@ -478,7 +513,7 @@ export default class TransactionService {
       console.log('Transaction failed', id, transaction.extrinsicHash);
 
       // Write failed transaction history
-      this.historyService.updateHistory(transaction.chain, transaction.extrinsicHash, {
+      this.historyService.updateHistories(transaction.chain, transaction.extrinsicHash, {
         status: ExtrinsicStatus.FAIL,
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
@@ -493,7 +528,7 @@ export default class TransactionService {
         notifyViaBrowser: true
       });
     }
-
+    this.eventService.emit('transaction.failed', transaction);
     // Log transaction errors
     console.error(errors);
   }

package/services/transaction-service/utils.js

@@ -1,22 +1,21 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { _getBlockExplorerFromChain, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
+
 // @ts-ignore
 export function parseTransactionData(data) {
-  // @ts-ignore
   // eslint-disable-next-line @typescript-eslint/no-unsafe-return
   return data;
 }
 export function getTransactionLink(chainInfo, extrinsicHash) {
-  if (chainInfo.evmInfo) {
-    var _chainInfo$evmInfo;
-    const explorerLink = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.blockExplorer;
+  const explorerLink = _getBlockExplorerFromChain(chainInfo);
+  if (_isPureEvmChain(chainInfo)) {
     if (explorerLink) {
       return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}tx/${extrinsicHash}`;
     }
   } else {
-    var _chainInfo$substrateI;
-    const explorerLink = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI = chainInfo.substrateInfo) === null || _chainInfo$substrateI === void 0 ? void 0 : _chainInfo$substrateI.blockExplorer;
+    const explorerLink = _getBlockExplorerFromChain(chainInfo);
     if (explorerLink) {
       return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}extrinsic/${extrinsicHash}`;
     }

package/utils/address.d.ts

@@ -1 +1,2 @@
 export declare const simpleAddress: (address: string) => string;
+export declare function quickFormatAddressToCompare(address?: string): string | undefined;

package/utils/address.js

@@ -1,10 +1,17 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { decodeAddress, encodeAddress, isEthereumAddress } from '@polkadot/util-crypto';
+import { reformatAddress } from '@subwallet/extension-base/utils/index';
+import { decodeAddress, encodeAddress, isAddress, isEthereumAddress } from '@polkadot/util-crypto';
 export const simpleAddress = address => {
   if (isEthereumAddress(address)) {
     return address;
   }
   return encodeAddress(decodeAddress(address));
-};
+};
+export function quickFormatAddressToCompare(address) {
+  if (!isAddress(address)) {
+    return address;
+  }
+  return reformatAddress(address, 42).toLowerCase();
+}

package/utils/index.d.ts

@@ -36,3 +36,4 @@ export declare const filterAndSortingAccountByAuthType: (accounts: AccountJson[]
 export declare function parseRawNumber(value: string): number;
 export declare function parseNumberToDisplay(amount: BN, decimals: number | undefined): string;
 export declare function isSameAddress(address1: string, address2: string): boolean;
+export declare function getDomainFromUrl(url: string): string;

package/utils/index.js

@@ -15,20 +15,25 @@ export function isAccountAll(address) {
   return address === ALL_ACCOUNT_KEY;
 }
 export function reformatAddress(address, networkPrefix, isEthereum = false) {
-  if (isEthereumAddress(address)) {
-    return address;
-  }
-  if (isAccountAll(address)) {
-    return address;
-  }
-  const publicKey = decodeAddress(address);
-  if (isEthereum) {
-    return ethereumEncode(publicKey);
-  }
-  if (networkPrefix < 0) {
+  try {
+    if (isEthereumAddress(address)) {
+      return address;
+    }
+    if (isAccountAll(address)) {
+      return address;
+    }
+    const publicKey = decodeAddress(address);
+    if (isEthereum) {
+      return ethereumEncode(publicKey);
+    }
+    if (networkPrefix < 0) {
+      return address;
+    }
+    return encodeAddress(publicKey, networkPrefix);
+  } catch (e) {
+    console.warn('Get error while reformat address', address, e);
     return address;
   }
-  return encodeAddress(publicKey, networkPrefix);
 }
 export function filterAddressByNetworkKey(addresses, networkKey, isEthereum) {
   if (isEthereum) {
@@ -272,4 +277,8 @@ export function parseNumberToDisplay(amount, decimals) {
 }
 export function isSameAddress(address1, address2) {
   return reformatAddress(address1, 0) === reformatAddress(address2, 0); // TODO: maybe there's a better way
+}
+
+export function getDomainFromUrl(url) {
+  return url.replace(/^(https?:\/\/)?(www\.)?/, '').split('/')[0];
 }

package/cjs/background/errors/EvmRpcError.js

@@ -1,21 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.EvmRpcError = void 0;
-var _ethereum = require("@subwallet/extension-base/constants/ethereum");
-// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-class EvmRpcError extends Error {
-  constructor(type, message, data) {
-    const [code, prefix] = _ethereum.EVM_PROVIDER_RPC_ERRORS_MAP[type];
-    const finalMessage = message ? `${prefix}: ${message}` : prefix;
-    super(finalMessage);
-    this.code = code;
-    this.message = finalMessage;
-    this.data = data;
-  }
-}
-exports.EvmRpcError = EvmRpcError;

package/cjs/background/errors/SubWalletProviderError.js

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SubWalletProviderError = void 0;
-// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-class SubWalletProviderError extends Error {
-  constructor(message, code, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-  }
-}
-exports.SubWalletProviderError = SubWalletProviderError;