@subwallet/extension-base 1.1.31-0 → 1.1.31-beta.0

package/services/earning-service/service.js

@@ -0,0 +1,379 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/earning-service/constants';
+import BaseLiquidStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/liquid-staking/base';
+import { YieldPoolType } from '@subwallet/extension-base/types';
+import { categoryAddresses } from '@subwallet/extension-base/utils';
+import { BehaviorSubject } from 'rxjs';
+import { AcalaLiquidStakingPoolHandler, AmplitudeNativeStakingPoolHandler, AstarNativeStakingPoolHandler, BifrostLiquidStakingPoolHandler, InterlayLendingPoolHandler, NominationPoolHandler, ParallelLiquidStakingPoolHandler, ParaNativeStakingPoolHandler, RelayNativeStakingPoolHandler, StellaSwapLiquidStakingPoolHandler } from "./handlers/index.js";
+export default class EarningService {
+  handlers = {};
+  earningRewardSubject = new BehaviorSubject({
+    ready: false,
+    data: {}
+  });
+  earningRewardHistorySubject = new BehaviorSubject({});
+  minAmountPercentSubject = new BehaviorSubject({});
+  constructor(state) {
+    this.state = state;
+    this.initHandlers().catch(console.error);
+  }
+  async initHandlers() {
+    await this.state.eventService.waitChainReady;
+    const chains = Object.keys(this.state.getChainInfoMap());
+    const minAmountPercent = {};
+    for (const chain of chains) {
+      const handlers = [];
+      if (_STAKING_CHAIN_GROUP.relay.includes(chain)) {
+        handlers.push(new RelayNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_STAKING_CHAIN_GROUP.para.includes(chain)) {
+        handlers.push(new ParaNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_STAKING_CHAIN_GROUP.astar.includes(chain)) {
+        handlers.push(new AstarNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+        handlers.push(new AmplitudeNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
+        handlers.push(new NominationPoolHandler(this.state, chain));
+      }
+      if (_STAKING_CHAIN_GROUP.liquidStaking.includes(chain)) {
+        if (chain === 'bifrost_dot') {
+          handlers.push(new BifrostLiquidStakingPoolHandler(this.state, chain));
+        }
+        if (chain === 'acala') {
+          handlers.push(new AcalaLiquidStakingPoolHandler(this.state, chain));
+        }
+        if (chain === 'parallel') {
+          handlers.push(new ParallelLiquidStakingPoolHandler(this.state, chain));
+        }
+        if (chain === 'moonbeam') {
+          handlers.push(new StellaSwapLiquidStakingPoolHandler(this.state, chain));
+        }
+      }
+      if (_STAKING_CHAIN_GROUP.lending.includes(chain)) {
+        if (chain === 'interlay') {
+          handlers.push(new InterlayLendingPoolHandler(this.state, chain));
+        }
+      }
+      for (const handler of handlers) {
+        this.handlers[handler.slug] = handler;
+      }
+    }
+    for (const handler of Object.values(this.handlers)) {
+      if (handler.type === YieldPoolType.LIQUID_STAKING) {
+        minAmountPercent[handler.slug] = handler.minAmountPercent;
+      }
+    }
+    minAmountPercent.default = BaseLiquidStakingPoolHandler.defaultMinAmountPercent;
+    this.minAmountPercentSubject.next(minAmountPercent);
+  }
+  getPoolHandler(slug) {
+    return this.handlers[slug];
+  }
+  isPoolSupportAlternativeFee(slug) {
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.isPoolSupportAlternativeFee;
+    } else {
+      throw new TransactionError(BasicTxErrorType.INTERNAL_ERROR);
+    }
+  }
+  subscribeMinAmountPercent() {
+    return this.minAmountPercentSubject;
+  }
+  getMinAmountPercent() {
+    return this.minAmountPercentSubject.getValue();
+  }
+
+  /* Subscribe pools' info */
+
+  async subscribePoolsInfo(callback) {
+    let cancel = false;
+    await this.state.eventService.waitChainReady;
+    const unsubList = [];
+    for (const handler of Object.values(this.handlers)) {
+      handler.subscribePoolInfo(callback).then(unsub => {
+        if (cancel) {
+          unsub();
+        } else {
+          unsubList.push(unsub);
+        }
+      }).catch(console.error);
+    }
+    return () => {
+      cancel = true;
+      unsubList.forEach(unsub => {
+        unsub === null || unsub === void 0 ? void 0 : unsub();
+      });
+    };
+  }
+
+  /* Subscribe pools' info */
+
+  /* Subscribe pools' position */
+
+  async subscribePoolPositions(addresses, callback) {
+    let cancel = false;
+    await this.state.eventService.waitChainReady;
+    const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
+    const activeChains = this.state.activeChainSlugs;
+    const unsubList = [];
+    for (const handler of Object.values(this.handlers)) {
+      if (activeChains.includes(handler.chain)) {
+        const chainInfo = handler.chainInfo;
+        const useAddresses = _isChainEvmCompatible(chainInfo) ? evmAddresses : substrateAddresses;
+        handler.subscribePoolPosition(useAddresses, callback).then(unsub => {
+          if (cancel) {
+            unsub();
+          } else {
+            unsubList.push(unsub);
+          }
+        }).catch(console.error);
+      }
+    }
+    return () => {
+      cancel = true;
+      unsubList.forEach(unsub => {
+        unsub === null || unsub === void 0 ? void 0 : unsub();
+      });
+    };
+  }
+
+  /* Subscribe pools' position */
+
+  /* Get pools' reward */
+
+  updateEarningReward(stakingRewardData) {
+    const stakingRewardState = this.earningRewardSubject.getValue();
+    stakingRewardState.ready = true;
+    const key = `${stakingRewardData.slug}---${stakingRewardData.address}`;
+    stakingRewardState.data[key] = stakingRewardData;
+    this.earningRewardSubject.next(stakingRewardState);
+  }
+  async getPoolReward(addresses, callback) {
+    let cancel = false;
+    await this.state.eventService.waitChainReady;
+    const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
+    const activeChains = this.state.activeChainSlugs;
+    const unsubList = [];
+    for (const handler of Object.values(this.handlers)) {
+      if (activeChains.includes(handler.chain)) {
+        const chainInfo = handler.chainInfo;
+        const useAddresses = _isChainEvmCompatible(chainInfo) ? evmAddresses : substrateAddresses;
+        handler.getPoolReward(useAddresses, callback).then(unsub => {
+          if (cancel) {
+            unsub();
+          } else {
+            unsubList.push(unsub);
+          }
+        }).catch(console.error);
+      }
+    }
+    return () => {
+      cancel = true;
+      unsubList.forEach(unsub => {
+        unsub === null || unsub === void 0 ? void 0 : unsub();
+      });
+    };
+  }
+  subscribeEarningReward() {
+    return this.earningRewardSubject;
+  }
+  getEarningRewards() {
+    return this.earningRewardSubject.getValue();
+  }
+  async fetchPoolRewardHistory(addresses, callback) {
+    let cancel = false;
+    await this.state.eventService.waitChainReady;
+    const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
+    const activeChains = this.state.activeChainSlugs;
+    const unsubList = [];
+    for (const handler of Object.values(this.handlers)) {
+      if (activeChains.includes(handler.chain)) {
+        const chainInfo = handler.chainInfo;
+        const useAddresses = _isChainEvmCompatible(chainInfo) ? evmAddresses : substrateAddresses;
+        handler.getPoolRewardHistory(useAddresses, callback).then(unsub => {
+          if (cancel) {
+            unsub();
+          } else {
+            unsubList.push(unsub);
+          }
+        }).catch(console.error);
+      }
+    }
+    return () => {
+      cancel = true;
+      unsubList.forEach(unsub => {
+        unsub === null || unsub === void 0 ? void 0 : unsub();
+      });
+    };
+  }
+  updateEarningRewardHistory(earningRewardHistory) {
+    const earningRewardHistoryState = this.earningRewardHistorySubject.getValue();
+    const key = `${earningRewardHistory.slug}---${earningRewardHistory.address}---${earningRewardHistory.blockTimestamp}`;
+    earningRewardHistoryState[key] = earningRewardHistory;
+    this.earningRewardHistorySubject.next(earningRewardHistoryState);
+  }
+  subscribeEarningRewardHistory() {
+    return this.earningRewardHistorySubject;
+  }
+  getEarningRewardHistory() {
+    return this.earningRewardHistorySubject.getValue();
+  }
+
+  /* Get pools' reward */
+
+  /* Get pool's targets */
+
+  /**
+   * @async
+   * @function getPoolTargets
+   * @param {string} slug - Pool's slug
+   * @return {Promise<YieldPoolTarget[]>} List of pool's target
+   * */
+  async getPoolTargets(slug) {
+    await this.state.eventService.waitChainReady;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return await handler.getPoolTargets();
+    } else {
+      return [];
+    }
+  }
+
+  /* Get pool's targets */
+
+  /* Handle actions */
+
+  /* Join */
+
+  async earlyValidateJoin(request) {
+    await this.state.eventService.waitChainReady;
+    const {
+      slug
+    } = request;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.earlyValidate(request);
+    } else {
+      throw new TransactionError(BasicTxErrorType.INTERNAL_ERROR);
+    }
+  }
+  async generateOptimalSteps(params) {
+    await this.state.eventService.waitChainReady;
+    const {
+      slug
+    } = params;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.generateOptimalPath(params);
+    } else {
+      throw new TransactionError(BasicTxErrorType.INTERNAL_ERROR);
+    }
+  }
+  async validateYieldJoin(params) {
+    await this.state.eventService.waitChainReady;
+    const {
+      slug
+    } = params.data;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.validateYieldJoin(params.data, params.path);
+    } else {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+  }
+  async handleYieldJoin(params) {
+    await this.state.eventService.waitChainReady;
+    const {
+      slug
+    } = params.data;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.handleYieldJoin(params.data, params.path, params.currentStep);
+    } else {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+
+  /* Join */
+
+  /* Leave */
+
+  async validateYieldLeave(params) {
+    await this.state.eventService.waitChainReady;
+    const {
+      slug
+    } = params;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.validateYieldLeave(params.amount, params.address, params.fastLeave, params.selectedTarget);
+    } else {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+  async handleYieldLeave(params) {
+    await this.state.eventService.waitChainReady;
+    const {
+      slug
+    } = params;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.handleYieldLeave(params.fastLeave, params.amount, params.address, params.selectedTarget);
+    } else {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+
+  /* Leave */
+
+  /* Other */
+
+  async handleYieldWithdraw(params) {
+    await this.state.eventService.waitChainReady;
+    const {
+      slug
+    } = params;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.handleYieldWithdraw(params.address, params.unstakingInfo);
+    } else {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+  async handleYieldCancelUnstake(params) {
+    await this.state.eventService.waitChainReady;
+    const {
+      slug
+    } = params;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.handleYieldCancelUnstake(params);
+    } else {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+  async handleYieldClaimReward(params) {
+    await this.state.eventService.waitChainReady;
+    const {
+      slug
+    } = params;
+    const handler = this.getPoolHandler(slug);
+    if (handler) {
+      return handler.handleYieldClaimReward(params.address, params.bondReward);
+    } else {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+
+  /* Other */
+
+  /* Handle actions */
+}

package/services/earning-service/utils/index.d.ts

@@ -0,0 +1,18 @@
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { LendingYieldPoolInfo, LiquidYieldPoolInfo, NativeYieldPoolInfo, NominationYieldPoolInfo, YieldAssetExpectedEarning, YieldCompoundingPeriod, YieldPoolInfo, YieldPoolType } from '@subwallet/extension-base/types';
+export declare function calculateReward(apr: number, amount?: number, compoundingPeriod?: YieldCompoundingPeriod, isApy?: boolean): YieldAssetExpectedEarning;
+/**
+ * @returns
+ * <p>
+ * [0] - identity
+ * </p>
+ * <p>
+ * [1] - isReasonable (isVerified)
+ * </p>
+ *  */
+export declare function parseIdentity(substrateApi: _SubstrateApi, address: string, children?: string): Promise<[string | undefined, boolean]>;
+export declare function isActionFromValidator(stakingType: YieldPoolType, chain: string): boolean;
+export declare const isNominationPool: (pool: YieldPoolInfo) => pool is NominationYieldPoolInfo;
+export declare const isNativeStakingPool: (pool: YieldPoolInfo) => pool is NativeYieldPoolInfo;
+export declare const isLiquidPool: (pool: YieldPoolInfo) => pool is LiquidYieldPoolInfo;
+export declare const isLendingPool: (pool: YieldPoolInfo) => pool is LendingYieldPoolInfo;

package/services/earning-service/utils/index.js

@@ -0,0 +1,112 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/earning-service/constants';
+import { YieldCompoundingPeriod, YieldPoolType } from '@subwallet/extension-base/types';
+import { hexToString, isHex } from '@polkadot/util';
+export function calculateReward(apr, amount = 0, compoundingPeriod = YieldCompoundingPeriod.YEARLY, isApy = false) {
+  if (!apr) {
+    return {};
+  }
+  if (!isApy) {
+    const periodApr = apr / 365 * compoundingPeriod; // APR is always annually
+    const earningRatio = periodApr / 100 / compoundingPeriod;
+    const periodApy = (1 + earningRatio) ** compoundingPeriod - 1;
+    const reward = periodApy * amount;
+    return {
+      apy: periodApy * 100,
+      rewardInToken: reward
+    };
+  } else {
+    const reward = apr / 100 * amount;
+    return {
+      apy: apr,
+      rewardInToken: reward * (compoundingPeriod / YieldCompoundingPeriod.YEARLY)
+    };
+  }
+}
+
+/**
+ * @returns
+ * <p>
+ * [0] - identity
+ * </p>
+ * <p>
+ * [1] - isReasonable (isVerified)
+ * </p>
+ *  */
+export async function parseIdentity(substrateApi, address, children) {
+  const compactResult = rs => {
+    const result = [];
+    if (rs) {
+      result.push(rs);
+    }
+    if (children) {
+      result.push(children);
+    }
+    if (result.length > 0) {
+      return result.join('/');
+    } else {
+      return undefined;
+    }
+  };
+  if (substrateApi.api.query.identity) {
+    let identity;
+    const _parent = await substrateApi.api.query.identity.superOf(address);
+    const parentInfo = _parent.toHuman();
+    if (parentInfo) {
+      const [parentAddress, {
+        Raw: data
+      }] = parentInfo;
+      const child = isHex(data) ? hexToString(data) : data;
+
+      // TODO: Re-check
+      if (address !== parentAddress) {
+        const [rs, isReasonable] = await parseIdentity(substrateApi, parentAddress, child);
+        return [compactResult(rs), isReasonable];
+      }
+    }
+    const _identity = await substrateApi.api.query.identity.identityOf(address);
+    const identityInfo = _identity.toHuman();
+    if (identityInfo) {
+      var _identityInfo$info, _identityInfo$info$di, _identityInfo$info2, _identityInfo$info2$w, _identityInfo$info3, _identityInfo$info3$r, _identityInfo$info4, _identityInfo$info4$t;
+      const displayName = (_identityInfo$info = identityInfo.info) === null || _identityInfo$info === void 0 ? void 0 : (_identityInfo$info$di = _identityInfo$info.display) === null || _identityInfo$info$di === void 0 ? void 0 : _identityInfo$info$di.Raw;
+      const web = (_identityInfo$info2 = identityInfo.info) === null || _identityInfo$info2 === void 0 ? void 0 : (_identityInfo$info2$w = _identityInfo$info2.web) === null || _identityInfo$info2$w === void 0 ? void 0 : _identityInfo$info2$w.Raw;
+      const riot = (_identityInfo$info3 = identityInfo.info) === null || _identityInfo$info3 === void 0 ? void 0 : (_identityInfo$info3$r = _identityInfo$info3.riot) === null || _identityInfo$info3$r === void 0 ? void 0 : _identityInfo$info3$r.Raw;
+      const twitter = (_identityInfo$info4 = identityInfo.info) === null || _identityInfo$info4 === void 0 ? void 0 : (_identityInfo$info4$t = _identityInfo$info4.twitter) === null || _identityInfo$info4$t === void 0 ? void 0 : _identityInfo$info4$t.Raw;
+      const isReasonable = identityInfo.judgements.length > 0;
+      if (displayName) {
+        identity = isHex(displayName) ? hexToString(displayName) : displayName;
+      } else {
+        identity = twitter || web || riot;
+      }
+      return [compactResult(identity), isReasonable];
+    }
+  }
+  return [undefined, false];
+}
+export function isActionFromValidator(stakingType, chain) {
+  if (stakingType === YieldPoolType.NOMINATION_POOL || stakingType === YieldPoolType.LIQUID_STAKING || stakingType === YieldPoolType.LENDING) {
+    return false;
+  }
+  if (_STAKING_CHAIN_GROUP.astar.includes(chain)) {
+    return true;
+  } else if (_STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+    return true;
+  } else if (_STAKING_CHAIN_GROUP.para.includes(chain)) {
+    return true;
+  }
+  return false;
+}
+export const isNominationPool = pool => {
+  return pool.type === YieldPoolType.NOMINATION_POOL;
+};
+export const isNativeStakingPool = pool => {
+  return pool.type === YieldPoolType.NATIVE_STAKING;
+};
+export const isLiquidPool = pool => {
+  return pool.type === YieldPoolType.LIQUID_STAKING;
+};
+export const isLendingPool = pool => {
+  return pool.type === YieldPoolType.LENDING;
+};

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

@@ -8,6 +8,7 @@ export declare class EventService extends EventEmitter<EventRegistry> {
     readonly waitDatabaseReady: Promise<boolean>;
     readonly waitKeyringReady: Promise<boolean>;
     readonly waitAccountReady: Promise<boolean>;
+    readonly waitInjectReady: Promise<boolean>;
     readonly waitChainReady: Promise<boolean>;
     readonly waitAssetReady: Promise<boolean>;
     readonly waitMigrateReady: Promise<boolean>;

package/services/event-service/index.js

@@ -3,6 +3,7 @@
 
 // Stateless service handle runtime event on background
 
+import { TARGET_ENV } from '@subwallet/extension-base/utils';
 import EventEmitter from 'eventemitter3';
 const DEFAULT_LAZY_TIME = 300;
 const LONG_LAZY_TIME = 900;
@@ -17,6 +18,8 @@ export class EventService extends EventEmitter {
     this.waitDatabaseReady = this.generateWaitPromise('database.ready');
     this.waitKeyringReady = this.generateWaitPromise('keyring.ready');
     this.waitAccountReady = this.generateWaitPromise('account.ready');
+    // TODO: Need to merge logic on web-runner file
+    this.waitInjectReady = TARGET_ENV === 'webapp' ? this.generateWaitPromise('inject.ready') : Promise.resolve(true);
     this.waitChainReady = this.generateWaitPromise('chain.ready');
     this.waitAssetReady = this.generateWaitPromise('asset.ready');
     this.waitMigrateReady = this.generateWaitPromise('migration.done');
@@ -27,6 +30,7 @@ export class EventService extends EventEmitter {
   generateWaitPromise(eventType) {
     return new Promise(resolve => {
       this.once(eventType, isReady => {
+        console.log('===LOG generateWaitPromise eventType', eventType);
         resolve(isReady);
       });
     });

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

@@ -5,12 +5,20 @@ export interface EventRegistry {
     'general.wakeup': [boolean];
     'crypto.ready': [boolean];
     'database.ready': [boolean];
+    /** Password state ready  */
     'keyring.ready': [boolean];
+    /** Update current account  */
     'account.updateCurrent': [CurrentAccountInfo];
+    /** Account list loaded  */
     'account.ready': [boolean];
+    /** Add a new account  */
     'account.add': [string];
+    /** Update account */
     'account.update': [string];
+    /** Remove a account  */
     'account.remove': [string];
+    /** Inject account done  */
+    'inject.ready': [boolean];
     'chain.ready': [boolean];
     'chain.add': [string];
     'chain.updateState': [string];

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

@@ -10,6 +10,7 @@ export declare class KeyringService {
     readonly addressesSubject: BehaviorSubject<SubjectInfo>;
     readonly accountSubject: BehaviorSubject<SubjectInfo>;
     private beforeAccount;
+    private injected;
     readonly keyringStateSubject: BehaviorSubject<KeyringState>;
     constructor(eventService: EventService);
     private subscribeAccounts;
@@ -21,6 +22,6 @@ export declare class KeyringService {
     setCurrentAccount(currentAccountData: CurrentAccountInfo): void;
     lock(): void;
     addInjectAccounts(accounts: InjectedAccountWithMeta[]): void;
-    removeInjectAccounts(addresses: string[]): void;
+    removeInjectAccounts(_addresses: string[]): void;
     resetWallet(resetAll: boolean): Promise<void>;
 }

package/services/keyring-service/index.js

@@ -22,6 +22,7 @@ export class KeyringService {
   });
   constructor(eventService) {
     this.eventService = eventService;
+    this.injected = false;
     this.eventService.waitCryptoReady.then(() => {
       this.currentAccountStore.get('CurrentAccountInfo', rs => {
         rs && this.currentAccountSubject.next(rs);
@@ -133,8 +134,19 @@ export class KeyringService {
         currentGenesisHash: null
       });
     }
+    if (!this.injected) {
+      this.eventService.emit('inject.ready', true);
+      this.injected = true;
+    }
   }
-  removeInjectAccounts(addresses) {
+  removeInjectAccounts(_addresses) {
+    const addresses = _addresses.map(address => {
+      try {
+        return keyring.getPair(address).address;
+      } catch (error) {
+        return address;
+      }
+    });
     const currentAddress = this.currentAccountSubject.value.address;
     const afterAccounts = Object.keys(this.accounts).filter(address => addresses.indexOf(address) < 0);
     if (afterAccounts.length === 1) {
@@ -159,7 +171,7 @@ export class KeyringService {
     await new Promise(resolve => {
       setTimeout(() => {
         resolve();
-      }, 500);
+      }, 1500);
     });
     this.updateKeyringState();
     this.currentAccountSubject.next({

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

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

package/services/migration-service/scripts/DeleteEarningData.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';
+export default class DeleteEarningData extends BaseMigrationJob {
+  async run() {
+    try {
+      await this.state.dbService.deleteYieldPoolInfo(['LcDOT___acala_euphrates_liquid_staking', 'xcDOT___moonwell_lending']);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}

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

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

package/services/migration-service/scripts/EnableEarningChains.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';
+export default class EnableEarningChains extends BaseMigrationJob {
+  async run() {
+    try {
+      await this.state.chainService.enableChains(['moonbeam', 'acala', 'bifrost_dot', 'interlay', 'parallel']);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}

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

@@ -11,7 +11,7 @@ export default class MigrateLedgerAccount extends BaseMigrationJob {
         const store = new AccountsStore();
         const update = (key, value) => {
           var _value$meta;
-          if (key.startsWith('account:') && value.meta && isString((_value$meta = value.meta) === null || _value$meta === void 0 ? void 0 : _value$meta.originGenesisHash)) {
+          if (key.startsWith('account:') && value !== null && value !== void 0 && value.meta && isString((_value$meta = value.meta) === null || _value$meta === void 0 ? void 0 : _value$meta.originGenesisHash)) {
             const newValue = {
               ...value
             };

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

@@ -12,7 +12,7 @@ export default class MigrateTransactionHistory extends BaseMigrationJob {
     const chainInfoMap = state.getChainInfoMap();
     const assetList = Object.values(state.getAssetRegistry());
     try {
-      const db = new Dexie('SubWalletDB');
+      const db = new Dexie('SubWalletDB_v2');
       const dexieDB = await db.open();
       const transactionTable = dexieDB.table('transactions');
       const oldTransactionData = await transactionTable.toArray();

package/services/migration-service/scripts/databases/MigrateEarningHistory.d.ts

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