@subwallet/extension-base 0.8.4-0 → 1.0.1

package/cjs/koni/background/handlers/index.js

@@ -0,0 +1,90 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = handlers;
+exports.tabs = exports.state = exports.nftHandler = exports.mobile = exports.extension = void 0;
+var _defaults = require("@subwallet/extension-base/defaults");
+var _nft = require("@subwallet/extension-base/koni/api/nft");
+var _Extension = _interopRequireDefault(require("@subwallet/extension-base/koni/background/handlers/Extension"));
+var _Mobile = _interopRequireDefault(require("@subwallet/extension-base/koni/background/handlers/Mobile"));
+var _State = _interopRequireDefault(require("@subwallet/extension-base/koni/background/handlers/State"));
+var _Tabs = _interopRequireDefault(require("@subwallet/extension-base/koni/background/handlers/Tabs"));
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// import Migration from '@subwallet/extension-base/koni/migration';
+
+const state = new _State.default();
+exports.state = state;
+const extension = new _Extension.default(state);
+exports.extension = extension;
+const tabs = new _Tabs.default(state);
+exports.tabs = tabs;
+const mobile = new _Mobile.default(state);
+exports.mobile = mobile;
+const nftHandler = new _nft.NftHandler();
+
+// Migration
+// async function makeSureStateReady () {
+//   const poll = (resolve: (value: unknown) => void) => {
+//     if (state.isReady()) {
+//       resolve(true);
+//     } else {
+//       console.log('Waiting for State is ready...');
+//       setTimeout(() => poll(resolve), 400);
+//     }
+//   };
+//
+//   return new Promise(poll);
+// }
+
+// makeSureStateReady().then(() => {
+//   const migration = new Migration(state);
+//
+//   migration.run().catch((err) => console.warn(err));
+// }).catch((e) => console.warn(e));
+exports.nftHandler = nftHandler;
+function handlers(_ref, port) {
+  let {
+    id,
+    message,
+    request
+  } = _ref;
+  let extensionPortName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _defaults.PORT_EXTENSION;
+  const isMobile = port.name === _defaults.PORT_MOBILE;
+  const isExtension = port.name === extensionPortName;
+  const sender = port.sender;
+  const from = isExtension ? 'extension' : sender.tab && sender.tab.url || sender.url || '<unknown>';
+  const source = `${from}: ${id}: ${message}`;
+  console.log(` [in] ${source}`); // :: ${JSON.stringify(request)}`);
+
+  const promise = isMobile ? mobile.handle(id, message, request, port) : isExtension ? extension.handle(id, message, request, port) : tabs.handle(id, message, request, from, port);
+  promise.then(response => {
+    console.log(`[out] ${source}`); // :: ${JSON.stringify(response)}`);
+
+    // between the start and the end of the promise, the user may have closed
+    // the tab, in which case port will be undefined
+    (0, _util.assert)(port, 'Port has been disconnected');
+    port.postMessage({
+      id,
+      response
+    });
+  }).catch(error => {
+    console.error(error);
+    console.log(`[err] ${source}:: ${error.message}`);
+
+    // only send message back to port if it's still connected
+    if (port) {
+      port.postMessage({
+        error: error.message,
+        errorCode: error.code,
+        errorData: error.data,
+        id
+      });
+    }
+  });
+}

package/cjs/koni/background/subscription.js

@@ -0,0 +1,281 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KoniSubscription = void 0;
+var _constants = require("@subwallet/extension-base/constants");
+var _balance = require("@subwallet/extension-base/koni/api/dotsama/balance");
+var _crowdloan = require("@subwallet/extension-base/koni/api/dotsama/crowdloan");
+var _staking = require("@subwallet/extension-base/koni/api/staking");
+var _bonding = require("@subwallet/extension-base/koni/api/staking/bonding");
+var _relayChain = require("@subwallet/extension-base/koni/api/staking/bonding/relayChain");
+var _paraChain = require("@subwallet/extension-base/koni/api/staking/paraChain");
+var _handlers = require("@subwallet/extension-base/koni/background/handlers");
+var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class KoniSubscription {
+  subscriptionMap = {
+    crowdloan: undefined,
+    balance: undefined,
+    stakingOnChain: undefined
+  };
+  constructor(state, dbService) {
+    this.dbService = dbService;
+    this.state = state;
+    this.logger = (0, _util.logger)('Subscription');
+    this.init();
+  }
+  getSubscriptionMap() {
+    return this.subscriptionMap;
+  }
+  getSubscription(name) {
+    return this.subscriptionMap[name];
+  }
+  updateSubscription(name, func) {
+    const oldFunc = this.subscriptionMap[name];
+    oldFunc && oldFunc();
+    func && (this.subscriptionMap[name] = func);
+  }
+  stopAllSubscription() {
+    if (this.subscriptionMap.balance) {
+      this.subscriptionMap.balance();
+      delete this.subscriptionMap.balance;
+    }
+    if (this.subscriptionMap.crowdloan) {
+      this.subscriptionMap.crowdloan();
+      delete this.subscriptionMap.crowdloan;
+    }
+    if (this.subscriptionMap.stakingOnChain) {
+      this.subscriptionMap.stakingOnChain();
+      delete this.subscriptionMap.stakingOnChain;
+    }
+  }
+  start() {
+    this.logger.log('Starting subscription');
+    this.state.getCurrentAccount(currentAccountInfo => {
+      if (currentAccountInfo) {
+        const {
+          address
+        } = currentAccountInfo;
+        this.subscribeBalancesAndCrowdloans(address, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap(), this.state.getEvmApiMap());
+        this.subscribeStakingOnChain(address, this.state.getSubstrateApiMap());
+      }
+    });
+    !this.serviceSubscription && (this.serviceSubscription = this.state.subscribeServiceInfo().subscribe({
+      next: serviceInfo => {
+        var _serviceInfo$currentA;
+        this.logger.log('ServiceInfo updated, restarting...');
+        const address = (_serviceInfo$currentA = serviceInfo.currentAccountInfo) === null || _serviceInfo$currentA === void 0 ? void 0 : _serviceInfo$currentA.address;
+        if (!address) {
+          return;
+        }
+        this.subscribeBalancesAndCrowdloans(address, serviceInfo.chainInfoMap, serviceInfo.chainStateMap, serviceInfo.chainApiMap.substrate, serviceInfo.chainApiMap.evm);
+        this.subscribeStakingOnChain(address, serviceInfo.chainApiMap.substrate);
+      }
+    }));
+  }
+  stop() {
+    this.logger.log('Stopping subscription');
+    if (this.serviceSubscription) {
+      this.serviceSubscription.unsubscribe();
+      this.serviceSubscription = undefined;
+    }
+    this.stopAllSubscription();
+  }
+  init() {
+    this.state.getAuthorize(value => {
+      const authString = localStorage.getItem('authUrls') || '{}';
+      const previousAuth = JSON.parse(authString);
+      if (previousAuth && Object.keys(previousAuth).length) {
+        Object.keys(previousAuth).forEach(url => {
+          if (previousAuth[url].isAllowed) {
+            previousAuth[url].isAllowedMap = this.state.getAddressList(true);
+          } else {
+            previousAuth[url].isAllowedMap = this.state.getAddressList();
+          }
+        });
+      }
+      const migrateValue = {
+        ...previousAuth,
+        ...value
+      };
+      this.state.setAuthorize(migrateValue);
+      localStorage.setItem('authUrls', '{}');
+    });
+  }
+  subscribeBalancesAndCrowdloans(address, chainInfoMap, chainStateMap, substrateApiMap, web3ApiMap, onlyRunOnFirstTime) {
+    this.state.switchAccount(address).then(() => {
+      this.state.getDecodedAddresses(address).then(addresses => {
+        if (!addresses.length) {
+          return;
+        }
+        this.updateSubscription('balance', this.initBalanceSubscription(addresses, chainInfoMap, chainStateMap, substrateApiMap, web3ApiMap, onlyRunOnFirstTime));
+        this.updateSubscription('crowdloan', this.initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
+      }).catch(this.logger.error);
+    }).catch(err => this.logger.warn(err));
+  }
+  subscribeStakingOnChain(address, substrateApiMap, onlyRunOnFirstTime) {
+    this.state.resetStaking(address).then(() => {
+      this.state.getDecodedAddresses(address).then(addresses => {
+        if (!addresses.length) {
+          return;
+        }
+        this.updateSubscription('stakingOnChain', this.initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
+      }).catch(this.logger.error);
+    }).catch(err => this.logger.warn(err));
+  }
+  initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime) {
+    const unsub = (0, _staking.stakingOnChainApi)(addresses, substrateApiMap, (networkKey, rs) => {
+      this.state.setStakingItem(networkKey, rs);
+    }, this.state.getActiveChainInfoMap());
+    if (onlyRunOnFirstTime) {
+      unsub && unsub();
+      return;
+    }
+    return () => {
+      unsub && unsub();
+    };
+  }
+  initBalanceSubscription(addresses, chainInfoMap, chainStateMap, substrateApiMap, evmApiMap, onlyRunOnFirstTime) {
+    const filteredChainInfoMap = {};
+    Object.values(chainInfoMap).forEach(chainInfo => {
+      if (chainStateMap[chainInfo.slug].active) {
+        filteredChainInfoMap[chainInfo.slug] = chainInfo;
+      }
+    });
+    const unsub = (0, _balance.subscribeBalance)(addresses, filteredChainInfoMap, substrateApiMap, evmApiMap, result => {
+      this.state.setBalanceItem(result.tokenSlug, result);
+    });
+    if (onlyRunOnFirstTime) {
+      unsub && unsub();
+      return;
+    }
+    return () => {
+      unsub && unsub();
+    };
+  }
+  initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime) {
+    const subscriptionPromise = (0, _crowdloan.subscribeCrowdloan)(addresses, substrateApiMap, (networkKey, rs) => {
+      this.state.setCrowdloanItem(networkKey, rs);
+    }, this.state.getChainInfoMap());
+    if (onlyRunOnFirstTime) {
+      subscriptionPromise.then(unsub => unsub()).catch(this.logger.warn);
+      return;
+    }
+    return () => {
+      subscriptionPromise.then(unsub => unsub()).catch(this.logger.warn);
+    };
+  }
+  subscribeNft(address, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap) {
+    this.state.getDecodedAddresses(address).then(addresses => {
+      if (!addresses.length) {
+        return;
+      }
+      this.initNftSubscription(addresses, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap);
+    }).catch(this.logger.error);
+  }
+  initNftSubscription(addresses, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap) {
+    var _this = this;
+    _handlers.nftHandler.setChainInfoMap(chainInfoMap);
+    _handlers.nftHandler.setDotSamaApiMap(substrateApiMap);
+    _handlers.nftHandler.setWeb3ApiMap(evmApiMap);
+    _handlers.nftHandler.setAddresses(addresses);
+    _handlers.nftHandler.handleNfts(smartContractNfts, function () {
+      return _this.state.updateNftData(...arguments);
+    }, function () {
+      return _this.state.setNftCollection(...arguments);
+    }).then(() => {
+      this.logger.log('nft state updated');
+    }).catch(this.logger.log);
+  }
+  async subscribeStakingReward(address) {
+    const addresses = await this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    const chainInfoMap = this.state.getChainInfoMap();
+    const targetNetworkMap = {};
+    Object.entries(chainInfoMap).forEach(_ref => {
+      let [key, network] = _ref;
+      const chainState = this.state.getChainStateByKey(key);
+      if ((0, _utils._isChainEnabled)(chainState) && (0, _utils._isChainSupportSubstrateStaking)(network)) {
+        targetNetworkMap[key] = network;
+      }
+    });
+    const result = await (0, _staking.getNominationStakingRewardData)(addresses, targetNetworkMap);
+    this.state.updateStakingReward(result, 'slowInterval');
+    this.logger.log('Set staking reward state done', result);
+  }
+  async subscribeStakingRewardFastInterval(address) {
+    const addresses = await this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    const pooledStakingItems = await this.state.getPooledStakingRecordsByAddress(addresses);
+    const pooledAddresses = [];
+    pooledStakingItems.forEach(pooledItem => {
+      if (!pooledAddresses.includes(pooledItem.address)) {
+        pooledAddresses.push(pooledItem.address);
+      }
+    });
+    const chainInfoMap = this.state.getChainInfoMap();
+    const targetChainMap = {};
+    Object.entries(chainInfoMap).forEach(_ref2 => {
+      let [key, network] = _ref2;
+      const chainState = this.state.getChainStateByKey(key);
+      if ((0, _utils._isChainEnabled)(chainState) && (0, _utils._isChainSupportSubstrateStaking)(network)) {
+        targetChainMap[key] = network;
+      }
+    });
+    const activeNetworks = [];
+    Object.keys(targetChainMap).forEach(key => {
+      activeNetworks.push(key);
+    });
+    const [poolingStakingRewards, amplitudeUnclaimedStakingRewards] = await Promise.all([(0, _staking.getPoolingStakingRewardData)(pooledAddresses, targetChainMap, this.state.getSubstrateApiMap()), (0, _paraChain.getAmplitudeUnclaimedStakingReward)(this.state.getSubstrateApiMap(), addresses, chainInfoMap, activeNetworks)]);
+    const result = [...poolingStakingRewards, ...amplitudeUnclaimedStakingRewards];
+    this.state.updateStakingReward(result, 'fastInterval');
+    this.logger.log('Set staking reward state with fast interval done', result);
+  }
+  async fetchChainStakingMetadata(chainInfoMap, chainStateMap, substrateApiMap) {
+    await Promise.all(Object.values(chainInfoMap).map(async chainInfo => {
+      const chainState = chainStateMap[chainInfo.slug];
+      if (chainState !== null && chainState !== void 0 && chainState.active && (0, _utils._isChainSupportSubstrateStaking)(chainInfo)) {
+        const chainStakingMetadata = await (0, _bonding.getChainStakingMetadata)(chainInfo.slug, substrateApiMap[chainInfo.slug]);
+        this.state.updateChainStakingMetadata(chainStakingMetadata);
+      }
+    }));
+  }
+  async fetchNominatorMetadata(currentAddress, chainInfoMap, chainStateMap, substrateApiMap) {
+    const filteredChainInfoMap = {};
+    Object.values(chainInfoMap).forEach(chainInfo => {
+      const chainState = chainStateMap[chainInfo.slug];
+      if (chainState !== null && chainState !== void 0 && chainState.active && (0, _utils._isChainSupportSubstrateStaking)(chainInfo)) {
+        filteredChainInfoMap[chainInfo.slug] = chainInfo;
+      }
+    });
+    let addresses = [currentAddress];
+    if (currentAddress === _constants.ALL_ACCOUNT_KEY) {
+      addresses = await this.state.getStakingOwnersByChains(Object.keys(filteredChainInfoMap));
+    }
+    await Promise.all(addresses.map(async address => {
+      await Promise.all(Object.values(filteredChainInfoMap).map(async chainInfo => {
+        if ((0, _utils._isSubstrateRelayChain)(chainInfo) && _constants2._STAKING_CHAIN_GROUP.nominationPool.includes(chainInfo.slug)) {
+          const poolMemberMetadata = await (0, _relayChain.getRelayChainPoolMemberMetadata)(chainInfo, address, substrateApiMap[chainInfo.slug]);
+          if (poolMemberMetadata) {
+            this.state.updateStakingNominatorMetadata(poolMemberMetadata);
+          }
+        }
+        const nominatorMetadata = await (0, _bonding.getNominatorMetadata)(chainInfo, address, substrateApiMap[chainInfo.slug]);
+        if (nominatorMetadata) {
+          this.state.updateStakingNominatorMetadata(nominatorMetadata);
+        }
+      }));
+    }));
+  }
+}
+exports.KoniSubscription = KoniSubscription;

package/cjs/koni/migration/Base.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class BaseMigrationJob {
+  constructor(state) {
+    this.state = state;
+    this.logger = (0, _util.logger)(this.constructor.name);
+  }
+  run() {
+    return Promise.resolve(console.warn('Need to override function run from base.'));
+  }
+}
+exports.default = BaseMigrationJob;

package/cjs/koni/migration/index.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _util = require("@polkadot/util");
+var _scripts = _interopRequireDefault(require("./scripts"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class Migration {
+  constructor(state) {
+    this.state = state;
+    this.logger = (0, _util.logger)('Migration');
+  }
+  async run() {
+    this.logger.log('Migrating...');
+    const keys = Object.keys(_scripts.default).sort((a, b) => a.localeCompare(b));
+    try {
+      for (let i = 0; i < keys.length; i++) {
+        const JobClass = _scripts.default[keys[i]];
+        const check = await this.state.dbService.stores.migration.table.where({
+          name: JobClass.name,
+          key: keys[i]
+        }).first();
+        if (!check) {
+          const job = new JobClass(this.state);
+          this.logger.log('Running script: ', JobClass.name);
+          await job.run();
+          await this.state.dbService.stores.migration.table.put({
+            key: keys[i],
+            name: JobClass.name,
+            timestamp: +new Date()
+          });
+        }
+      }
+    } catch (error) {
+      this.logger.warn('Migration error: ', error);
+    }
+    this.logger.log('Migration done.');
+  }
+}
+exports.default = Migration;

package/cjs/koni/migration/scripts/ChangeRouteToHome.js

@@ -0,0 +1,22 @@
+"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/koni/migration/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class ChangeRouteToHome extends _Base.default {
+  async run() {
+    const deletedRoutes = ['/account/import-evm-token', '/account/import-evm-nft', '/account/evm-token-setting', '/account/evm-token-edit', '/account/import-evm-token', '/account/import-evm-nft', '/account/evm-token-setting', '/account/evm-token-edit'];
+    const currentRoute = window.localStorage.getItem('popupNavigation');
+    if (currentRoute !== null && deletedRoutes.includes(currentRoute)) {
+      window.localStorage.setItem('popupNavigation', '/');
+    }
+    return Promise.resolve();
+  }
+}
+exports.default = ChangeRouteToHome;

package/cjs/koni/migration/scripts/ClearOldStorage.js

@@ -0,0 +1,24 @@
+"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/koni/migration/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class ClearOldStorage extends _Base.default {
+  async run() {
+    // new BalanceStore().removeAll();
+    // new CrowdloanStore().removeAll();
+    // new StakingStore().removeAll();
+    // new NftStore().removeAll();
+    // new NftCollectionStore().removeAll();
+    // // Todo: clear transaction history data
+
+    return Promise.resolve();
+  }
+}
+exports.default = ClearOldStorage;

package/cjs/koni/migration/scripts/RemoveWrongCrowdloan.js

@@ -0,0 +1,19 @@
+"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/koni/migration/Base"));
+var _databases = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/databases"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class RemoveWrongCrowdloan extends _Base.default {
+  async run() {
+    const db = new _databases.default();
+    await db.crowdloans.clear();
+  }
+}
+exports.default = RemoveWrongCrowdloan;

package/cjs/koni/migration/scripts/RemoveWrongTransactionHistoriesFromStore.js

@@ -0,0 +1,36 @@
+"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/koni/migration/Base"));
+var _TransactionHistoryV = _interopRequireDefault(require("@subwallet/extension-base/stores/TransactionHistoryV3"));
+var _accounts = require("@subwallet/ui-keyring/observable/accounts");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class RemoveWrongTransactionHistoriesFromStore extends _Base.default {
+  async run() {
+    const newStore = new _TransactionHistoryV.default();
+    const addressList = Object.keys(_accounts.accounts.subject.value);
+    for (const address of addressList) {
+      const oldHistories = await newStore.asyncGet(address);
+      const newHistories = {};
+      Object.entries(oldHistories).forEach(_ref => {
+        let [hash, items] = _ref;
+        // Remove wrong stored history (missing eventIdx)
+        const newItems = items.items.filter(item => item.origin === 'app');
+        newHistories[hash] = {
+          items: newItems,
+          total: newItems.length
+        };
+      });
+      if (Object.keys(newHistories).length > 0) {
+        newStore.set(address, newHistories);
+      }
+    }
+  }
+}
+exports.default = RemoveWrongTransactionHistoriesFromStore;

package/cjs/koni/migration/scripts/ResetTransactionHistoryEventIdx.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/koni/migration/Base"));
+var _databases = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/databases"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class ResetTransactionHistoryEventIdx extends _Base.default {
+  async run() {
+    const db = new _databases.default();
+    const oldData = await db.transactions.toArray();
+    await db.transactions.clear();
+    await db.transactions.bulkAdd(oldData);
+  }
+}
+exports.default = ResetTransactionHistoryEventIdx;

package/cjs/koni/migration/scripts/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ChangeRouteToHome = _interopRequireDefault(require("@subwallet/extension-base/koni/migration/scripts/ChangeRouteToHome"));
+var _RemoveWrongCrowdloan = _interopRequireDefault(require("@subwallet/extension-base/koni/migration/scripts/RemoveWrongCrowdloan"));
+var _ResetTransactionHistoryEventIdx = _interopRequireDefault(require("@subwallet/extension-base/koni/migration/scripts/ResetTransactionHistoryEventIdx"));
+var _ClearOldStorage = _interopRequireDefault(require("./ClearOldStorage"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+var _default = {
+  // '0.5.3-2': FixMissingTransactionHistory,
+  // '0.5.3-3-1': ConvertTransactionHistoryFromChromeStorageToIndexedDB, // Can run multiple times with different key
+  '0.5.6-1': _ClearOldStorage.default,
+  '0.6.6-1': _ChangeRouteToHome.default,
+  '0.7.5-0': _ResetTransactionHistoryEventIdx.default,
+  '0.7.9-0': _RemoveWrongCrowdloan.default
+};
+exports.default = _default;