@subwallet/extension-base 0.7.10-0 → 0.8.1-wr2x

package/koni/background/handlers/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="chrome" />
+import { MessageTypes, TransportRequestMessage } from '@subwallet/extension-base/background/types';
+import { NftHandler } from '@subwallet/extension-base/koni/api/nft';
+import KoniExtension from '@subwallet/extension-base/koni/background/handlers/Extension';
+import Mobile from '@subwallet/extension-base/koni/background/handlers/Mobile';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import KoniTabs from '@subwallet/extension-base/koni/background/handlers/Tabs';
+export declare const state: KoniState;
+export declare const extension: KoniExtension;
+export declare const tabs: KoniTabs;
+export declare const mobile: Mobile;
+export declare const nftHandler: NftHandler;
+export default function handlers<TMessageType extends MessageTypes>({ id, message, request }: TransportRequestMessage<TMessageType>, port: chrome.runtime.Port, extensionPortName?: string): void;

package/koni/background/handlers/index.js

@@ -0,0 +1,76 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { PORT_EXTENSION, PORT_MOBILE } from '@subwallet/extension-base/defaults';
+import { NftHandler } from '@subwallet/extension-base/koni/api/nft';
+import KoniExtension from '@subwallet/extension-base/koni/background/handlers/Extension';
+import Mobile from '@subwallet/extension-base/koni/background/handlers/Mobile';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import KoniTabs from '@subwallet/extension-base/koni/background/handlers/Tabs';
+
+// import Migration from '@subwallet/extension-base/koni/migration';
+import { assert } from '@polkadot/util';
+export const state = new KoniState();
+export const extension = new KoniExtension(state);
+export const tabs = new KoniTabs(state);
+export const mobile = new Mobile(state);
+export const nftHandler = new 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));
+
+export default function handlers({
+  id,
+  message,
+  request
+}, port, extensionPortName = PORT_EXTENSION) {
+  const isMobile = port.name === 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
+    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/koni/background/subscription.d.ts

@@ -0,0 +1,32 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { _ChainState, _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import KoniState from './handlers/State';
+declare type SubscriptionName = 'balance' | 'crowdloan' | 'stakingOnChain';
+export declare class KoniSubscription {
+    private serviceSubscription;
+    private subscriptionMap;
+    dbService: DatabaseService;
+    private state;
+    private logger;
+    constructor(state: KoniState, dbService: DatabaseService);
+    getSubscriptionMap(): Record<SubscriptionName, (() => void) | undefined>;
+    getSubscription(name: SubscriptionName): (() => void) | undefined;
+    updateSubscription(name: SubscriptionName, func: (() => void) | undefined): void;
+    stopAllSubscription(): void;
+    start(): void;
+    stop(): void;
+    init(): void;
+    subscribeBalancesAndCrowdloans(address: string, chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>, web3ApiMap: Record<string, _EvmApi>, onlyRunOnFirstTime?: boolean): void;
+    subscribeStakingOnChain(address: string, substrateApiMap: Record<string, _SubstrateApi>, onlyRunOnFirstTime?: boolean): void;
+    initStakingOnChainSubscription(addresses: string[], substrateApiMap: Record<string, _SubstrateApi>, onlyRunOnFirstTime?: boolean): (() => void) | undefined;
+    initBalanceSubscription(addresses: string[], chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, onlyRunOnFirstTime?: boolean): (() => void) | undefined;
+    initCrowdloanSubscription(addresses: string[], substrateApiMap: Record<string, _SubstrateApi>, onlyRunOnFirstTime?: boolean): (() => void) | undefined;
+    subscribeNft(address: string, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>): void;
+    initNftSubscription(addresses: string[], substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>): void;
+    subscribeStakingReward(address: string): Promise<void>;
+    subscribeStakingRewardFastInterval(address: string): Promise<void>;
+    fetchChainStakingMetadata(chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>): Promise<void>;
+    fetchNominatorMetadata(currentAddress: string, chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>): Promise<void>;
+}
+export {};

package/koni/background/subscription.js

@@ -0,0 +1,287 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { subscribeBalance } from '@subwallet/extension-base/koni/api/dotsama/balance';
+import { subscribeCrowdloan } from '@subwallet/extension-base/koni/api/dotsama/crowdloan';
+import { getNominationStakingRewardData, getPoolingStakingRewardData, stakingOnChainApi } from '@subwallet/extension-base/koni/api/staking';
+import { getChainStakingMetadata, getNominatorMetadata } from '@subwallet/extension-base/koni/api/staking/bonding';
+import { getRelayChainPoolMemberMetadata } from '@subwallet/extension-base/koni/api/staking/bonding/relayChain';
+import { getAmplitudeUnclaimedStakingReward } from '@subwallet/extension-base/koni/api/staking/paraChain';
+import { nftHandler } from '@subwallet/extension-base/koni/background/handlers';
+import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _isChainEnabled, _isChainSupportSubstrateStaking, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { logger as createLogger } from '@polkadot/util';
+export class KoniSubscription {
+  subscriptionMap = {
+    crowdloan: undefined,
+    balance: undefined,
+    stakingOnChain: undefined
+  };
+  constructor(state, dbService) {
+    this.dbService = dbService;
+    this.state = state;
+    this.logger = createLogger('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 = 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 = 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 = 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) {
+    const {
+      cronUpdate,
+      forceUpdate,
+      selectedNftCollection
+    } = this.state.getNftTransfer();
+    if (forceUpdate && !cronUpdate) {
+      this.logger.log('skipping set nft state due to transfer');
+      this.state.setNftTransfer({
+        cronUpdate: true,
+        forceUpdate: true,
+        selectedNftCollection
+      });
+    } else {
+      // after skipping 1 time of cron update
+      this.state.setNftTransfer({
+        cronUpdate: false,
+        forceUpdate: false,
+        selectedNftCollection
+      });
+      nftHandler.setChainInfoMap(chainInfoMap);
+      nftHandler.setDotSamaApiMap(substrateApiMap);
+      nftHandler.setWeb3ApiMap(evmApiMap);
+      nftHandler.setAddresses(addresses);
+      nftHandler.handleNfts(smartContractNfts, (...args) => this.state.updateNftData(...args), (...args) => this.state.setNftCollection(...args), (...args) => this.state.updateNftIds(...args), (...args) => this.state.updateCollectionIds(...args)).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(([key, network]) => {
+      const chainState = this.state.getChainStateByKey(key);
+      if (_isChainEnabled(chainState) && _isChainSupportSubstrateStaking(network)) {
+        targetNetworkMap[key] = network;
+      }
+    });
+    const result = await 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(([key, network]) => {
+      const chainState = this.state.getChainStateByKey(key);
+      if (_isChainEnabled(chainState) && _isChainSupportSubstrateStaking(network)) {
+        targetChainMap[key] = network;
+      }
+    });
+    const activeNetworks = [];
+    Object.keys(targetChainMap).forEach(key => {
+      activeNetworks.push(key);
+    });
+    const [poolingStakingRewards, amplitudeUnclaimedStakingRewards] = await Promise.all([getPoolingStakingRewardData(pooledAddresses, targetChainMap, this.state.getSubstrateApiMap()), 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 && _isChainSupportSubstrateStaking(chainInfo)) {
+        const chainStakingMetadata = await 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 && _isChainSupportSubstrateStaking(chainInfo)) {
+        filteredChainInfoMap[chainInfo.slug] = chainInfo;
+      }
+    });
+    let addresses = [currentAddress];
+    if (currentAddress === 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 (_isSubstrateRelayChain(chainInfo) && _STAKING_CHAIN_GROUP.nominationPool.includes(chainInfo.slug)) {
+          const poolMemberMetadata = await getRelayChainPoolMemberMetadata(chainInfo, address, substrateApiMap[chainInfo.slug]);
+          if (poolMemberMetadata) {
+            this.state.updateStakingNominatorMetadata(poolMemberMetadata);
+          }
+        }
+        const nominatorMetadata = await getNominatorMetadata(chainInfo, address, substrateApiMap[chainInfo.slug]);
+        if (nominatorMetadata) {
+          this.state.updateStakingNominatorMetadata(nominatorMetadata);
+        }
+      }));
+    }));
+  }
+}

package/koni/migration/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/koni/migration/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/koni/migration/index.d.ts

@@ -0,0 +1,7 @@
+import State from '@subwallet/extension-base/koni/background/handlers/State';
+export default class Migration {
+    readonly state: State;
+    private logger;
+    constructor(state: State);
+    run(): Promise<void>;
+}

package/koni/migration/index.js

@@ -0,0 +1,37 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { logger as createLogger } from '@polkadot/util';
+import MigrationScripts from "./scripts/index.js";
+export default class Migration {
+  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 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.');
+  }
+}

package/koni/migration/scripts/ChangeRouteToHome.d.ts

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

package/koni/migration/scripts/ChangeRouteToHome.js

@@ -0,0 +1,14 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/koni/migration/Base';
+export default class ChangeRouteToHome extends BaseMigrationJob {
+  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();
+  }
+}

package/koni/migration/scripts/ClearOldStorage.d.ts

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

package/koni/migration/scripts/ClearOldStorage.js

@@ -0,0 +1,16 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/koni/migration/Base';
+export default class ClearOldStorage extends BaseMigrationJob {
+  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();
+  }
+}

package/koni/migration/scripts/RemoveWrongCrowdloan.d.ts

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

package/koni/migration/scripts/RemoveWrongCrowdloan.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/koni/migration/Base';
+import KoniDatabase from '@subwallet/extension-base/services/storage-service/databases';
+export default class RemoveWrongCrowdloan extends BaseMigrationJob {
+  async run() {
+    const db = new KoniDatabase();
+    await db.crowdloans.clear();
+  }
+}

package/koni/migration/scripts/RemoveWrongTransactionHistoriesFromStore.d.ts

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

package/koni/migration/scripts/RemoveWrongTransactionHistoriesFromStore.js

@@ -0,0 +1,27 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/koni/migration/Base';
+import TransactionHistoryStoreV3 from '@subwallet/extension-base/stores/TransactionHistoryV3';
+import { accounts } from '@subwallet/ui-keyring/observable/accounts';
+export default class RemoveWrongTransactionHistoriesFromStore extends BaseMigrationJob {
+  async run() {
+    const newStore = new TransactionHistoryStoreV3();
+    const addressList = Object.keys(accounts.subject.value);
+    for (const address of addressList) {
+      const oldHistories = await newStore.asyncGet(address);
+      const newHistories = {};
+      Object.entries(oldHistories).forEach(([hash, items]) => {
+        // 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);
+      }
+    }
+  }
+}

package/koni/migration/scripts/ResetTransactionHistoryEventIdx.d.ts

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

package/koni/migration/scripts/ResetTransactionHistoryEventIdx.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/koni/migration/Base';
+import KoniDatabase from '@subwallet/extension-base/services/storage-service/databases';
+export default class ResetTransactionHistoryEventIdx extends BaseMigrationJob {
+  async run() {
+    const db = new KoniDatabase();
+    const oldData = await db.transactions.toArray();
+    await db.transactions.clear();
+    await db.transactions.bulkAdd(oldData);
+  }
+}

package/koni/migration/scripts/index.d.ts

@@ -0,0 +1,3 @@
+import BaseMigrationJob from '../Base';
+declare const _default: Record<string, typeof BaseMigrationJob>;
+export default _default;

package/koni/migration/scripts/index.js

@@ -0,0 +1,15 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import ChangeRouteToHome from '@subwallet/extension-base/koni/migration/scripts/ChangeRouteToHome';
+import RemoveWrongCrowdloan from '@subwallet/extension-base/koni/migration/scripts/RemoveWrongCrowdloan';
+import ResetTransactionHistoryEventIdx from '@subwallet/extension-base/koni/migration/scripts/ResetTransactionHistoryEventIdx';
+import ClearOldStorage from "./ClearOldStorage.js";
+export default {
+  // '0.5.3-2': FixMissingTransactionHistory,
+  // '0.5.3-3-1': ConvertTransactionHistoryFromChromeStorageToIndexedDB, // Can run multiple times with different key
+  '0.5.6-1': ClearOldStorage,
+  '0.6.6-1': ChangeRouteToHome,
+  '0.7.5-0': ResetTransactionHistoryEventIdx,
+  '0.7.9-0': RemoveWrongCrowdloan
+};

package/koni/page/SubWalleEvmProvider.d.ts

@@ -0,0 +1,27 @@
+import type { EvmProvider } from '@subwallet/extension-inject/types';
+import SafeEventEmitter from '@metamask/safe-event-emitter';
+import { SendRequest } from '@subwallet/extension-base/page/types';
+import { JsonRpcRequest, JsonRpcResponse } from 'json-rpc-engine';
+import { RequestArguments } from 'web3-core';
+export interface SendSyncJsonRpcRequest extends JsonRpcRequest<unknown> {
+    method: 'net_version';
+}
+export declare class SubWalletEvmProvider extends SafeEventEmitter implements EvmProvider {
+    readonly isSubWallet = true;
+    readonly isMetaMask = false;
+    readonly version: string;
+    protected sendMessage: SendRequest;
+    protected _connected: boolean;
+    protected _subscribed: boolean;
+    constructor(sendMessage: SendRequest, version: string);
+    get connected(): boolean;
+    isConnected(): boolean;
+    protected subscribeExtensionEvents(): void;
+    enable(): Promise<unknown>;
+    request<T>({ method, params }: RequestArguments): Promise<T>;
+    private _sendSync;
+    send<T>(method: string, params?: T[]): Promise<JsonRpcResponse<T>>;
+    send<T>(payload: JsonRpcRequest<unknown>, callback: (error: Error | null, result?: JsonRpcResponse<T>) => void): void;
+    send<T>(payload: SendSyncJsonRpcRequest): JsonRpcResponse<T>;
+    sendAsync<T>(payload: JsonRpcRequest<T>, callback: (error: (Error | null), result?: JsonRpcResponse<T>) => void): void;
+}