@subwallet/extension-base 1.1.29-0 → 1.1.29-beta.1

package/cjs/services/earning-service/service.js

@@ -0,0 +1,387 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _constants = require("@subwallet/extension-base/services/earning-service/constants");
+var _base = _interopRequireDefault(require("@subwallet/extension-base/services/earning-service/handlers/liquid-staking/base"));
+var _types = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _rxjs = require("rxjs");
+var _handlers = require("./handlers");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class EarningService {
+  handlers = {};
+  earningRewardSubject = new _rxjs.BehaviorSubject({
+    ready: false,
+    data: {}
+  });
+  earningRewardHistorySubject = new _rxjs.BehaviorSubject({});
+  minAmountPercentSubject = new _rxjs.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 (_constants._STAKING_CHAIN_GROUP.relay.includes(chain)) {
+        handlers.push(new _handlers.RelayNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_constants._STAKING_CHAIN_GROUP.para.includes(chain)) {
+        handlers.push(new _handlers.ParaNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_constants._STAKING_CHAIN_GROUP.astar.includes(chain)) {
+        handlers.push(new _handlers.AstarNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+        handlers.push(new _handlers.AmplitudeNativeStakingPoolHandler(this.state, chain));
+      }
+      if (_constants._STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
+        handlers.push(new _handlers.NominationPoolHandler(this.state, chain));
+      }
+      if (_constants._STAKING_CHAIN_GROUP.liquidStaking.includes(chain)) {
+        if (chain === 'bifrost_dot') {
+          handlers.push(new _handlers.BifrostLiquidStakingPoolHandler(this.state, chain));
+        }
+        if (chain === 'acala') {
+          handlers.push(new _handlers.AcalaLiquidStakingPoolHandler(this.state, chain));
+        }
+        if (chain === 'parallel') {
+          handlers.push(new _handlers.ParallelLiquidStakingPoolHandler(this.state, chain));
+        }
+        if (chain === 'moonbeam') {
+          handlers.push(new _handlers.StellaSwapLiquidStakingPoolHandler(this.state, chain));
+        }
+      }
+      if (_constants._STAKING_CHAIN_GROUP.lending.includes(chain)) {
+        if (chain === 'interlay') {
+          handlers.push(new _handlers.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 === _types.YieldPoolType.LIQUID_STAKING) {
+        minAmountPercent[handler.slug] = handler.minAmountPercent;
+      }
+    }
+    minAmountPercent.default = _base.default.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.TransactionError(_KoniTypes.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] = (0, _utils2.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 = (0, _utils._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] = (0, _utils2.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 = (0, _utils._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] = (0, _utils2.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 = (0, _utils._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.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+    }
+  }
+
+  /* Other */
+
+  /* Handle actions */
+}
+exports.default = EarningService;

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

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateReward = calculateReward;
+exports.isActionFromValidator = isActionFromValidator;
+exports.isNominationPool = exports.isNativeStakingPool = exports.isLiquidPool = exports.isLendingPool = void 0;
+exports.parseIdentity = parseIdentity;
+var _constants = require("@subwallet/extension-base/services/earning-service/constants");
+var _types = require("@subwallet/extension-base/types");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function calculateReward(apr) {
+  let amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  let compoundingPeriod = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _types.YieldCompoundingPeriod.YEARLY;
+  let isApy = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 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 / _types.YieldCompoundingPeriod.YEARLY)
+    };
+  }
+}
+
+/**
+ * @returns
+ * <p>
+ * [0] - identity
+ * </p>
+ * <p>
+ * [1] - isReasonable (isVerified)
+ * </p>
+ *  */
+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 = (0, _util.isHex)(data) ? (0, _util.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 = (0, _util.isHex)(displayName) ? (0, _util.hexToString)(displayName) : displayName;
+      } else {
+        identity = twitter || web || riot;
+      }
+      return [compactResult(identity), isReasonable];
+    }
+  }
+  return [undefined, false];
+}
+function isActionFromValidator(stakingType, chain) {
+  if (stakingType === _types.YieldPoolType.NOMINATION_POOL || stakingType === _types.YieldPoolType.LIQUID_STAKING || stakingType === _types.YieldPoolType.LENDING) {
+    return false;
+  }
+  if (_constants._STAKING_CHAIN_GROUP.astar.includes(chain)) {
+    return true;
+  } else if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+    return true;
+  } else if (_constants._STAKING_CHAIN_GROUP.para.includes(chain)) {
+    return true;
+  }
+  return false;
+}
+const isNominationPool = pool => {
+  return pool.type === _types.YieldPoolType.NOMINATION_POOL;
+};
+exports.isNominationPool = isNominationPool;
+const isNativeStakingPool = pool => {
+  return pool.type === _types.YieldPoolType.NATIVE_STAKING;
+};
+exports.isNativeStakingPool = isNativeStakingPool;
+const isLiquidPool = pool => {
+  return pool.type === _types.YieldPoolType.LIQUID_STAKING;
+};
+exports.isLiquidPool = isLiquidPool;
+const isLendingPool = pool => {
+  return pool.type === _types.YieldPoolType.LENDING;
+};
+exports.isLendingPool = isLendingPool;

package/cjs/services/event-service/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.EventService = void 0;
+var _utils = require("@subwallet/extension-base/utils");
 var _eventemitter = _interopRequireDefault(require("eventemitter3"));
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
@@ -24,6 +25,8 @@ class EventService extends _eventemitter.default {
     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 = _utils.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');
@@ -34,6 +37,7 @@ class EventService extends _eventemitter.default {
   generateWaitPromise(eventType) {
     return new Promise(resolve => {
       this.once(eventType, isReady => {
+        console.log('===LOG generateWaitPromise eventType', eventType);
         resolve(isReady);
       });
     });

package/cjs/services/keyring-service/index.js

@@ -28,6 +28,7 @@ class KeyringService {
   });
   constructor(eventService) {
     this.eventService = eventService;
+    this.injected = false;
     this.eventService.waitCryptoReady.then(() => {
       this.currentAccountStore.get('CurrentAccountInfo', rs => {
         rs && this.currentAccountSubject.next(rs);
@@ -140,8 +141,19 @@ 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 _uiKeyring.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) {
@@ -166,7 +178,7 @@ class KeyringService {
     await new Promise(resolve => {
       setTimeout(() => {
         resolve();
-      }, 500);
+      }, 1500);
     });
     this.updateKeyringState();
     this.currentAccountSubject.next({

package/cjs/services/migration-service/scripts/DeleteEarningData.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class DeleteEarningData extends _Base.default {
+  async run() {
+    try {
+      await this.state.dbService.deleteYieldPoolInfo(['LcDOT___acala_euphrates_liquid_staking', 'xcDOT___moonwell_lending']);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+exports.default = DeleteEarningData;

package/cjs/services/migration-service/scripts/EnableEarningChains.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class EnableEarningChains extends _Base.default {
+  async run() {
+    try {
+      await this.state.chainService.enableChains(['moonbeam', 'acala', 'bifrost_dot', 'interlay', 'parallel']);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+exports.default = EnableEarningChains;

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

@@ -18,7 +18,7 @@ class MigrateLedgerAccount extends _Base.default {
         const store = new _stores.AccountsStore();
         const update = (key, value) => {
           var _value$meta;
-          if (key.startsWith('account:') && value.meta && (0, _util.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 && (0, _util.isString)((_value$meta = value.meta) === null || _value$meta === void 0 ? void 0 : _value$meta.originGenesisHash)) {
             const newValue = {
               ...value
             };

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

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

package/cjs/services/migration-service/scripts/databases/MigrateEarningHistory.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateEarningHistory extends _Base.default {
+  async run() {
+    try {
+      await this.state.dbService.removeOldEarningData();
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+exports.default = MigrateEarningHistory;

package/cjs/services/migration-service/scripts/databases/MigrateEarningVersion.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateEarningVersion extends _Base.default {
+  async run() {
+    try {
+      await this.state.dbService.removeOldEarningData();
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+exports.default = MigrateEarningVersion;