@subwallet/extension-base 0.8.4-0 → 1.0.2-1

package/services/history-service/index.js

@@ -0,0 +1,121 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { CRON_REFRESH_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
+import { quickFormatAddressToCompare } from '@subwallet/extension-base/utils/address';
+import { keyring } from '@subwallet/ui-keyring';
+import { accounts } from '@subwallet/ui-keyring/observable/accounts';
+import { BehaviorSubject } from 'rxjs';
+import { fetchMultiChainHistories } from "./subsquid-multi-chain-history.js";
+export class HistoryService {
+  historySubject = new BehaviorSubject([]);
+  constructor(dbService, chainService, eventService) {
+    this.dbService = dbService;
+    this.chainService = chainService;
+    this.eventService = eventService;
+    // Load history from database
+    this.dbService.getHistories().then(histories => {
+      this.historySubject.next(histories);
+    }).catch(console.error);
+
+    // Wait for keyring and chain ready and start
+    Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
+      this.getHistories().catch(console.log);
+      this.eventService.on('account.add', () => {
+        this.refreshHistoryInterval();
+      });
+      this.eventService.on('account.remove', address => {
+        this.removeHistoryByAddress(address).catch(console.error);
+      });
+    }).catch(console.error);
+  }
+  fetchPromise = null;
+  nextFetch = undefined;
+  async fetchAndLoadHistories(addresses) {
+    if (!addresses || addresses.length === 0) {
+      return [];
+    }
+    const chainMap = this.chainService.getChainInfoMap();
+
+    // Query data from subscan or any indexer
+    const historyRecords = await fetchMultiChainHistories(addresses, chainMap);
+
+    // Fill additional info
+    const accountMap = Object.entries(accounts.subject.value).reduce((map, [address, account]) => {
+      map[address.toLowerCase()] = account.json.meta.name || address;
+      return map;
+    }, {});
+    historyRecords.forEach(record => {
+      var _record$from, _record$to;
+      record.fromName = accountMap[(_record$from = record.from) === null || _record$from === void 0 ? void 0 : _record$from.toLowerCase()];
+      record.toName = accountMap[(_record$to = record.to) === null || _record$to === void 0 ? void 0 : _record$to.toLowerCase()];
+    });
+    this.dbService.upsertHistory(historyRecords).catch(console.error);
+    return historyRecords;
+  }
+  async fetchHistories(addresses) {
+    if (!this.fetchPromise) {
+      // Fetch another histories data data indexer and merge it with stored in database
+      this.fetchPromise = this.fetchAndLoadHistories(addresses);
+    }
+    return this.fetchPromise;
+  }
+  invalidCache() {
+    this.fetchPromise = null;
+  }
+  refreshHistoryInterval() {
+    clearTimeout(this.nextFetch);
+    this.invalidCache();
+    this.getHistories().catch(console.error);
+    this.nextFetch = setTimeout(() => {
+      this.refreshHistoryInterval();
+    }, CRON_REFRESH_HISTORY_INTERVAL);
+  }
+  async getHistories() {
+    const addressList = keyring.getAccounts().map(a => a.address);
+    const currentHistories = this.historySubject.value;
+    if (!this.fetchPromise || currentHistories.length === 0) {
+      const historyRecords = await this.fetchHistories(addressList);
+      this.historySubject.next(historyRecords);
+    }
+    return this.historySubject.getValue();
+  }
+  async getHistorySubject() {
+    await this.getHistories();
+    return this.historySubject;
+  }
+  async insertHistories(historyItems) {
+    await this.dbService.upsertHistory(historyItems);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
+  async updateHistories(chain, extrinsicHash, updateData) {
+    const existedRecords = await this.dbService.getHistories({
+      chain,
+      extrinsicHash
+    });
+    const updatedRecords = existedRecords.map(r => {
+      return {
+        ...r,
+        ...updateData
+      };
+    });
+    await this.addHistoryItems(updatedRecords);
+  }
+  async addHistoryItems(historyItems) {
+    // Prevent override record with original is 'app'
+    const appRecords = this.historySubject.value.filter(item => item.origin === 'app');
+    const excludeKeys = appRecords.map(item => {
+      return `${item.chain}-${quickFormatAddressToCompare(item.address) || ''}-${item.extrinsicHash}`;
+    });
+    const updateRecords = historyItems.filter(item => {
+      const key = `${item.chain}-${quickFormatAddressToCompare(item.address) || ''}-${item.extrinsicHash}`;
+      return item.origin === 'app' || !excludeKeys.includes(key);
+    });
+    await this.dbService.upsertHistory(updateRecords);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
+  async removeHistoryByAddress(address) {
+    await this.dbService.stores.transaction.removeAllByAddress(address);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
+}

package/services/history-service/subsquid-multi-chain-history.d.ts

@@ -0,0 +1,30 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ExtrinsicType, TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+export interface MultiHistoryData {
+    _data: string;
+    args: string;
+    chainId: string;
+    id: string;
+    signer: string;
+    name: string;
+    timestamp: number | string;
+    blockNumber: number;
+    blockHash: string;
+    explorerUrl: string;
+    relatedAddresses: string[];
+}
+export declare enum SubsquidTransactionType {
+    BalanceTransfer = "Balances.Transfer",
+    EthereumExecuted = "Ethereum.Executed",
+    StakingBonded = "Staking.Bonded",
+    CrowdloanContributed = "Crowdloan.Contributed"
+}
+export interface ParseInputType {
+    type: SubsquidTransactionType;
+    data: MultiHistoryData;
+    chainInfo: _ChainInfo;
+}
+export declare type TransactionBasicData = Pick<TransactionHistoryItem, 'address' | 'origin' | 'time' | 'chainType' | 'from' | 'direction' | 'blockNumber' | 'blockHash' | 'chain' | 'data'>;
+export declare type TransactionSpecifyType = Pick<TransactionHistoryItem, 'to' | 'type' | 'status' | 'fee' | 'amount' | 'tip' | 'signature' | 'extrinsicHash'>;
+export declare function parseSubsquidTransactionData(address: string, type: SubsquidTransactionType, historyItem: MultiHistoryData, chainInfo: _ChainInfo, args: any, data: any): TransactionHistoryItem;
+export declare function fetchMultiChainHistories(addresses: string[], chainMap: Record<string, _ChainInfo>, maxPage?: number): Promise<TransactionHistoryItem<ExtrinsicType.TRANSFER_BALANCE>[]>;

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

@@ -0,0 +1,256 @@
+// 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 || '0';
+        fee = (parseInt(transaction.gasPrice) * parseInt(transaction.gasLimit)).toString();
+        signature = generateSignature(transaction.signature);
+        success = extrinsic.success;
+
+        // Special fix for moonbeam
+        if ((historyItem.chainId === 'moonbeam' || historyItem.chainId === 'moonriver') && typeof amount === 'object') {
+          amount = amount[0];
+        }
+        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: 'subsquid',
+    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/keyring-service/index.d.ts

@@ -0,0 +1,19 @@
+import { CurrentAccountInfo, KeyringState } from '@subwallet/extension-base/background/KoniTypes';
+import { EventService } from '@subwallet/extension-base/services/event-service';
+import { SubjectInfo } from '@subwallet/ui-keyring/observable/types';
+import { BehaviorSubject } from 'rxjs';
+export declare class KeyringService {
+    private readonly currentAccountStore;
+    readonly currentAccountSubject: BehaviorSubject<CurrentAccountInfo>;
+    readonly accountsSubject: BehaviorSubject<SubjectInfo>;
+    private beforeAccount;
+    readonly keyringStateSubject: BehaviorSubject<KeyringState>;
+    private eventService;
+    constructor(eventService: EventService);
+    private subscribeAccounts;
+    get keyringState(): KeyringState;
+    updateKeyringState(isReady?: boolean): void;
+    get accounts(): SubjectInfo;
+    get currentAccount(): CurrentAccountInfo;
+    setCurrentAccount(currentAccountData: CurrentAccountInfo): void;
+}

package/services/keyring-service/index.js

@@ -0,0 +1,93 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { CurrentAccountStore } from '@subwallet/extension-base/stores';
+import { keyring } from '@subwallet/ui-keyring';
+import { BehaviorSubject } from 'rxjs';
+export class KeyringService {
+  currentAccountStore = new CurrentAccountStore();
+  currentAccountSubject = new BehaviorSubject({
+    address: '',
+    currentGenesisHash: null
+  });
+  accountsSubject = keyring.accounts.subject;
+  beforeAccount = keyring.accounts.subject.value;
+  keyringStateSubject = new BehaviorSubject({
+    isReady: false,
+    hasMasterPassword: false,
+    isLocked: false
+  });
+  constructor(eventService) {
+    this.eventService = eventService;
+    this.currentAccountStore.get('CurrentAccountInfo', rs => {
+      this.currentAccountSubject.next(rs);
+    });
+    this.subscribeAccounts().catch(console.error);
+  }
+  async subscribeAccounts() {
+    // Wait until account ready
+    await new Promise(resolve => {
+      const onReady = () => {
+        this.eventService.off('account.ready', onReady);
+        resolve(true);
+      };
+      this.eventService.on('account.ready', onReady);
+    });
+    this.beforeAccount = {
+      ...this.accountsSubject.value
+    };
+    this.accountsSubject.subscribe(subjectInfo => {
+      // Check if accounts changed
+      const beforeAddresses = Object.keys(this.beforeAccount);
+      const afterAddresses = Object.keys(subjectInfo);
+      if (beforeAddresses.length > afterAddresses.length) {
+        const removedAddresses = beforeAddresses.filter(address => !afterAddresses.includes(address));
+
+        // Remove account
+        removedAddresses.forEach(address => {
+          console.log('account.remove', address);
+          this.eventService.emit('account.remove', address);
+        });
+      } else if (beforeAddresses.length < afterAddresses.length) {
+        const addedAddresses = afterAddresses.filter(address => !beforeAddresses.includes(address));
+
+        // Add account
+        addedAddresses.forEach(address => {
+          console.log('account.add', address);
+          this.eventService.emit('account.add', address);
+        });
+      } else {
+        // Handle case update later
+      }
+      this.beforeAccount = {
+        ...subjectInfo
+      };
+    });
+  }
+  get keyringState() {
+    return this.keyringStateSubject.value;
+  }
+  updateKeyringState(isReady = true) {
+    var _keyring$keyring, _keyring$keyring2;
+    if (!this.keyringState.isReady && isReady) {
+      this.eventService.emit('keyring.ready', true);
+      this.eventService.emit('account.ready', true);
+    }
+    this.keyringStateSubject.next({
+      hasMasterPassword: !!((_keyring$keyring = keyring.keyring) !== null && _keyring$keyring !== void 0 && _keyring$keyring.hasMasterPassword),
+      isLocked: !!((_keyring$keyring2 = keyring.keyring) !== null && _keyring$keyring2 !== void 0 && _keyring$keyring2.isLocked),
+      isReady: isReady
+    });
+  }
+  get accounts() {
+    return this.accountsSubject.value;
+  }
+  get currentAccount() {
+    return this.currentAccountSubject.value;
+  }
+  setCurrentAccount(currentAccountData) {
+    this.currentAccountSubject.next(currentAccountData);
+    this.eventService.emit('account.updateCurrent', currentAccountData);
+    this.currentAccountStore.set('CurrentAccountInfo', currentAccountData);
+  }
+}

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,39 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { logger as createLogger } from '@polkadot/util';
+import MigrationScripts, { EVERYTIME } 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 key = keys[i];
+        const name = JobClass.name;
+        const check = await this.state.dbService.stores.migration.table.where({
+          name,
+          key
+        }).first();
+        if (!check || key.startsWith(EVERYTIME)) {
+          this.logger.log('Running script: ', JobClass.name);
+          const job = new JobClass(this.state);
+          await job.run();
+          await this.state.dbService.stores.migration.table.put({
+            key,
+            name,
+            timestamp: new Date().getTime()
+          });
+        }
+      }
+    } catch (error) {
+      this.logger.error('Migration error: ', error);
+    }
+    this.logger.log('Migration done.');
+  }
+}

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

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

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

@@ -0,0 +1,13 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+import { keyring } from '@subwallet/ui-keyring';
+export default class AutoEnableChainsTokens extends BaseMigrationJob {
+  async run() {
+    const accounts = keyring.getAccounts();
+    await this.state.autoEnableChains(accounts.map(({
+      address
+    }) => address));
+  }
+}

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();
+      });
+    });
+  }
+}