@subwallet/extension-base 1.1.22-0 → 1.1.24-0

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _promise = require("@subwallet/extension-base/utils/promise");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -26,6 +27,7 @@ const DEFAULT_SERVICE_MAP = {
 class Mobile {
   // @ts-ignore
 
+  restoreHandler = (0, _promise.createPromiseHandler)();
   constructor(state) {
     this.state = state;
   }
@@ -102,6 +104,32 @@ class Mobile {
   restartSubscriptionServices(services) {
     console.log('restartSubscriptionServices');
   }
+  async mobileBackup() {
+    const indexedDB = await this.state.dbService.exportDB();
+    return {
+      storage: JSON.stringify(localStorage),
+      indexedDB
+    };
+  }
+  async mobileRestore(_ref5) {
+    let {
+      indexedDB,
+      storage
+    } = _ref5;
+    if (storage) {
+      const storageData = JSON.parse(storage);
+      for (const key in storageData) {
+        localStorage.setItem(key, JSON.stringify(storageData[key]));
+      }
+    }
+    if (indexedDB) {
+      await this.state.dbService.importDB(indexedDB);
+    }
+    this.restoreHandler.resolve();
+  }
+  waitRestore() {
+    return this.restoreHandler.promise;
+  }
 
   // eslint-disable-next-line @typescript-eslint/require-await
   async handle(id, type, request, port) {
@@ -130,6 +158,10 @@ class Mobile {
         return this.stopSubscriptionServices(request);
       case 'mobile(subscription.restart)':
         return this.restartSubscriptionServices(request);
+      case 'mobile(storage.restore)':
+        return this.mobileRestore(request);
+      case 'mobile(storage.backup)':
+        return this.mobileBackup();
       default:
         throw new Error(`Unable to handle message of type ${type}`);
     }

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

@@ -91,14 +91,14 @@ class KoniState {
     this.eventService = new _eventService.EventService();
     this.dbService = new _DatabaseService.default(this.eventService);
     this.keyringService = new _keyringService.KeyringService(this.eventService);
-    this.subscanService = new _subscanService.SubscanService();
     this.notificationService = new _NotificationService.default();
     this.chainService = new _chainService.ChainService(this.dbService, this.eventService);
+    this.subscanService = new _subscanService.SubscanService(_subscanChainMap.SUBSCAN_API_CHAIN_MAP);
     this.settingService = new _SettingService.default();
     this.requestService = new _requestService.default(this.chainService, this.settingService, this.keyringService);
     this.priceService = new _priceService.PriceService(this.dbService, this.eventService, this.chainService);
     this.balanceService = new _balanceService.BalanceService(this.chainService);
-    this.historyService = new _historyService.HistoryService(this.dbService, this.chainService, this.eventService, this.keyringService);
+    this.historyService = new _historyService.HistoryService(this.dbService, this.chainService, this.eventService, this.keyringService, this.subscanService);
     this.transactionService = new _transactionService.default(this.chainService, this.eventService, this.requestService, this.balanceService, this.historyService, this.notificationService, this.dbService);
     this.walletConnectService = new _walletConnectService.default(this, this.requestService);
     this.migrationService = new _migrationService.default(this, this.eventService);
@@ -109,7 +109,9 @@ class KoniState {
     this.logger = (0, _util.logger)('State');
 
     // Init state
-    this.init().catch(console.error);
+    if (_utils2.TARGET_ENV !== 'mobile') {
+      this.init().catch(console.error);
+    }
   }
 
   // Clone from polkadot.js
@@ -206,9 +208,13 @@ class KoniState {
     });
     return balanceMap;
   }
+  afterChainServiceInit() {
+    this.subscanService.setSubscanChainMap(this.chainService.getSubscanChainMap());
+  }
   async init() {
     await this.eventService.waitCryptoReady;
     await this.chainService.init();
+    this.afterChainServiceInit();
     await this.migrationService.run();
     this.eventService.emit('chain.ready', true);
     this.onReady();
@@ -1494,7 +1500,7 @@ class KoniState {
           network,
           symbol
         } = _ref11;
-        const chain = _subscanChainMap.SUBSCAN_CHAIN_MAP_REVERSE[network];
+        const chain = _subscanChainMap.SUBSCAN_BALANCE_CHAIN_MAP_REVERSE[network];
         const chainInfo = chain ? chainMap[chain] : null;
         const balanceIsEmpty = (!balance || balance === '0') && (!locked || locked === '0') && (!bonded || bonded === '0');
 
@@ -1503,10 +1509,11 @@ class KoniState {
           return;
         }
         const tokenKey = `${chain}-${category === 'native' ? 'NATIVE' : 'LOCAL'}-${symbol.toUpperCase()}`;
-        if (assetMap[tokenKey] && !((_currentAssetSettings = currentAssetSettings[tokenKey]) !== null && _currentAssetSettings !== void 0 && _currentAssetSettings.visible)) {
+        const existedKey = Object.keys(assetMap).find(v => v.toLowerCase() === tokenKey.toLowerCase());
+        if (existedKey && !((_currentAssetSettings = currentAssetSettings[existedKey]) !== null && _currentAssetSettings !== void 0 && _currentAssetSettings.visible)) {
           needEnableChains.push(chain);
-          needActiveTokens.push(tokenKey);
-          currentAssetSettings[tokenKey] = {
+          needActiveTokens.push(existedKey);
+          currentAssetSettings[existedKey] = {
             visible: true
           };
         }
@@ -1578,6 +1585,7 @@ class KoniState {
     this.chainService.resetWallet(resetAll);
     await this.walletConnectService.resetWallet(resetAll);
     await this.chainService.init();
+    this.afterChainServiceInit();
   }
   async enableMantaPay(updateStore, address, password, seedPhrase) {
     var _this$chainService3, _this$chainService3$m, _this$chainService4, _this$chainService4$m, _this$chainService4$m2, _this$chainService11, _this$chainService11$, _this$chainService11$2;

package/cjs/koni/background/subscription.js

@@ -169,7 +169,7 @@ class KoniSubscription {
   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 && unsub();

package/cjs/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '1.1.22-0'
+  version: '1.1.24-0'
 };
 exports.packageInfo = packageInfo;

package/cjs/services/chain-service/constants.js

@@ -41,7 +41,9 @@ const _BALANCE_CHAIN_GROUP = {
   equilibrium_parachain: ['equilibrium_parachain'],
   bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main', 'pendulum', 'amplitude'],
   statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel', 'calamari'],
-  kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'] // perhaps there are some runtime updates
+  kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'],
+  // perhaps there are some runtime updates
+  centrifuge: ['centrifuge']
 };
 exports._BALANCE_CHAIN_GROUP = _BALANCE_CHAIN_GROUP;
 const _BALANCE_TOKEN_GROUP = {
@@ -211,7 +213,8 @@ const _TRANSFER_CHAIN_GROUP = {
   riochain: ['riochain'],
   sora_substrate: ['sora_substrate'],
   avail: ['kate', 'goldberg_testnet'],
-  pendulum: ['pendulum', 'amplitude', 'amplitude_test']
+  pendulum: ['pendulum', 'amplitude', 'amplitude_test'],
+  centrifuge: ['centrifuge']
 };
 exports._TRANSFER_CHAIN_GROUP = _TRANSFER_CHAIN_GROUP;
 const _BALANCE_PARSING_CHAIN_GROUP = {

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

@@ -1399,5 +1399,23 @@ class ChainService {
   getMetadataByHash(hash) {
     return this.dbService.stores.metadata.getMetadataByGenesisHash(hash);
   }
+  getSubscanChainMap(reverse) {
+    const result = {};
+    const chainInfoMap = this.getChainInfoMap();
+    Object.values(chainInfoMap).forEach(i => {
+      var _i$extraInfo;
+      if (!((_i$extraInfo = i.extraInfo) !== null && _i$extraInfo !== void 0 && _i$extraInfo.subscanSlug)) {
+        return;
+      }
+      if (!reverse) {
+        var _i$extraInfo2;
+        result[i.slug] = (_i$extraInfo2 = i.extraInfo) === null || _i$extraInfo2 === void 0 ? void 0 : _i$extraInfo2.subscanSlug;
+      } else {
+        var _i$extraInfo3;
+        result[(_i$extraInfo3 = i.extraInfo) === null || _i$extraInfo3 === void 0 ? void 0 : _i$extraInfo3.subscanSlug] = i.slug;
+      }
+    });
+    return result;
+  }
 }
 exports.ChainService = ChainService;

package/cjs/services/history-service/helpers/subscan-extrinsic-parser-helper.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExtrinsicParserKey = getExtrinsicParserKey;
+exports.supportedExtrinsicParser = exports.subscanExtrinsicParserMap = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function getExtrinsicParserKey(extrinsicItem) {
+  return `${extrinsicItem.call_module}.${extrinsicItem.call_module_function}`;
+}
+function paramJsonParse(item) {
+  try {
+    return JSON.parse(item.data || '[]');
+  } catch (e) {
+    return [];
+  }
+}
+function balanceTransferParserFunction(item) {
+  const params = paramJsonParse(item);
+  params.forEach(p => {
+    if (p.name === 'dest') {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      const toPublicKey = p.value.id || p.value.Id;
+      if (toPublicKey) {
+        item.to = (0, _utilCrypto.encodeAddress)(toPublicKey, 42);
+      }
+    } else if (p.name === 'value') {
+      if (item.amount) {
+        item.amount.value = p.value;
+      }
+    }
+  });
+  item.type = _KoniTypes.ExtrinsicType.TRANSFER_BALANCE;
+  if (!item.to) {
+    return null;
+  }
+  return item;
+}
+
+// todo: will support other type later
+const subscanExtrinsicParserMap = {
+  'balances.transfer': balanceTransferParserFunction,
+  'balances.transfer_keep_alive': balanceTransferParserFunction,
+  'balances.transfer_allow_death': balanceTransferParserFunction
+};
+exports.subscanExtrinsicParserMap = subscanExtrinsicParserMap;
+const supportedExtrinsicParser = Object.keys(subscanExtrinsicParserMap);
+exports.supportedExtrinsicParser = supportedExtrinsicParser;

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

@@ -8,24 +8,32 @@ var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _constants = require("@subwallet/extension-base/constants");
 var _types = require("@subwallet/extension-base/services/base/types");
 var _recoverHistoryStatus = require("@subwallet/extension-base/services/history-service/helpers/recoverHistoryStatus");
+var _subscanExtrinsicParserHelper = require("@subwallet/extension-base/services/history-service/helpers/subscan-extrinsic-parser-helper");
+var _subscanHistory = require("@subwallet/extension-base/services/history-service/subscan-history");
+var _utils = require("@subwallet/extension-base/utils");
 var _promise = require("@subwallet/extension-base/utils/promise");
 var _uiKeyring = require("@subwallet/ui-keyring");
 var _rxjs = require("rxjs");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+function filterHistoryItemByAddressAndChain(chain, address) {
+  return item => {
+    return item.chain === chain && item.address === address;
+  };
+}
 class HistoryService {
   historySubject = new _rxjs.BehaviorSubject([]);
   #needRecoveryHistories = {};
-  constructor(dbService, chainService, eventService, keyringService) {
+  constructor(dbService, chainService, eventService, keyringService, subscanService) {
     this.dbService = dbService;
     this.chainService = chainService;
     this.eventService = eventService;
     this.keyringService = keyringService;
+    this.subscanService = subscanService;
     this.init().catch(console.error);
   }
   fetchPromise = null;
-  interval = undefined;
   recoverInterval = undefined;
   async fetchAndLoadHistories(addresses) {
     if (!addresses || addresses.length === 0) {
@@ -67,6 +75,74 @@ class HistoryService {
     await this.getHistories();
     return this.historySubject;
   }
+  fetchSubscanTransactionHistory(chain, address) {
+    if (!this.subscanService.checkSupportedSubscanChain(chain)) {
+      return;
+    }
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const excludeExtrinsicParserKeys = ['balances.transfer_all'];
+
+    // Note: fetchAllPossibleExtrinsicItems and fetchAllPossibleTransferItems-receive can run parallelly
+    // Hover, fetchAllPossibleTransferItems-sent must run after fetchAllPossibleExtrinsicItems,
+    // to avoid "duplicate Extrinsic Hash between items" problem
+
+    this.subscanService.fetchAllPossibleExtrinsicItems(chain, address, extrinsicItems => {
+      const result = [];
+      extrinsicItems.forEach(x => {
+        const item = (0, _subscanHistory.parseSubscanExtrinsicData)(address, x, chainInfo);
+        if (item) {
+          result.push(item);
+        }
+      });
+      this.addHistoryItems(result).catch(e => {
+        console.log('addHistoryItems in fetchAllPossibleExtrinsicItems error', e);
+      });
+    }).then(extrinsicItems => {
+      const excludeTransferExtrinsicHash = [];
+      extrinsicItems.forEach(x => {
+        if (!excludeExtrinsicParserKeys.includes((0, _subscanExtrinsicParserHelper.getExtrinsicParserKey)(x))) {
+          excludeTransferExtrinsicHash.push(x.extrinsic_hash);
+        }
+      });
+      this.subscanService.fetchAllPossibleTransferItems(chain, address, 'sent', transferItems => {
+        const result = [];
+        transferItems.forEach(t => {
+          if (!excludeTransferExtrinsicHash.includes(t.hash)) {
+            result.push((0, _subscanHistory.parseSubscanTransferData)(address, t, chainInfo));
+          }
+        });
+        this.addHistoryItems(result).catch(e => {
+          console.log('addHistoryItems in fetchAllPossibleTransferItems-sent error', e);
+        });
+      }).catch(e => {
+        console.log('fetchAllPossibleTransferItems-sent error', e);
+      });
+    }).catch(e => {
+      console.log('fetchAllPossibleExtrinsicItems error', e);
+    });
+    this.subscanService.fetchAllPossibleTransferItems(chain, address, 'received', transferItems => {
+      const result = [];
+      transferItems.forEach(t => {
+        result.push((0, _subscanHistory.parseSubscanTransferData)(address, t, chainInfo));
+      });
+      this.addHistoryItems(result).catch(e => {
+        console.log('addHistoryItems in fetchAllPossibleTransferItems-receive error', e);
+      });
+    }).catch(e => {
+      console.log('fetchAllPossibleTransferItems-receive error', e);
+    });
+  }
+  subscribeHistories(chain, address, cb) {
+    const _address = (0, _utils.reformatAddress)(address);
+    const subscription = this.historySubject.subscribe(items => {
+      cb(items.filter(filterHistoryItemByAddressAndChain(chain, _address)));
+    });
+    this.fetchSubscanTransactionHistory(chain, _address);
+    return {
+      unsubscribe: subscription.unsubscribe,
+      value: this.historySubject.getValue().filter(filterHistoryItemByAddressAndChain(chain, _address))
+    };
+  }
   async updateHistories(chain, extrinsicHash, updateData) {
     const existedRecords = await this.dbService.getHistories({
       chain,
@@ -117,17 +193,6 @@ class HistoryService {
   async persistData() {
     await this.dbService.upsertHistory(this.historySubject.value);
   }
-  async startCron() {
-    await this.getHistories();
-    this.interval = setInterval(() => {
-      this.getHistories().catch(console.error);
-    }, _constants.CRON_REFRESH_HISTORY_INTERVAL);
-  }
-  stopCron() {
-    clearTimeout(this.interval);
-    this.fetchPromise = null;
-    return Promise.resolve();
-  }
   async startRecoverHistories() {
     await this.recoverHistories();
     this.recoverInterval = setInterval(() => {
@@ -182,12 +247,6 @@ class HistoryService {
     Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
       this.getHistories().catch(console.log);
       this.recoverProcessingHistory().catch(console.error);
-      this.eventService.on('account.add', () => {
-        (async () => {
-          await this.stopCron();
-          await this.startCron();
-        })().catch(console.error);
-      });
       this.eventService.on('account.remove', address => {
         this.removeHistoryByAddress(address).catch(console.error);
       });
@@ -216,7 +275,6 @@ class HistoryService {
       await Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]);
       this.startPromiseHandler = (0, _promise.createPromiseHandler)();
       this.status = _types.ServiceStatus.STARTING;
-      await this.startCron();
       this.status = _types.ServiceStatus.STARTED;
       this.startPromiseHandler.resolve();
     } catch (e) {
@@ -232,7 +290,6 @@ class HistoryService {
       this.stopPromiseHandler = (0, _promise.createPromiseHandler)();
       this.status = _types.ServiceStatus.STOPPING;
       await this.persistData();
-      await this.stopCron();
       await this.stopRecoverHistories();
       this.stopPromiseHandler.resolve();
       this.status = _types.ServiceStatus.STOPPED;

package/cjs/services/history-service/subscan-history.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseSubscanExtrinsicData = parseSubscanExtrinsicData;
+exports.parseSubscanTransferData = parseSubscanTransferData;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _subscanExtrinsicParserHelper = require("@subwallet/extension-base/services/history-service/helpers/subscan-extrinsic-parser-helper");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function autoFormatAddress(address) {
+  try {
+    if ((0, _utilCrypto.isEthereumAddress)(address)) {
+      return address;
+    } else {
+      const decoded = (0, _utilCrypto.decodeAddress)(address);
+      return (0, _utilCrypto.encodeAddress)(decoded, 42);
+    }
+  } catch (e) {
+    return '';
+  }
+}
+function parseSubscanExtrinsicData(address, extrinsicItem, chainInfo) {
+  var _chainInfo$substrateI, _chainInfo$evmInfo, _chainInfo$substrateI2, _chainInfo$evmInfo2;
+  const extrinsicParserKey = (0, _subscanExtrinsicParserHelper.getExtrinsicParserKey)(extrinsicItem);
+  if (!_subscanExtrinsicParserHelper.supportedExtrinsicParser.includes(extrinsicParserKey)) {
+    return null;
+  }
+  const chainType = chainInfo.substrateInfo ? _KoniTypes.ChainType.SUBSTRATE : _KoniTypes.ChainType.EVM;
+  const nativeDecimals = ((_chainInfo$substrateI = chainInfo.substrateInfo) === null || _chainInfo$substrateI === void 0 ? void 0 : _chainInfo$substrateI.decimals) || ((_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.decimals) || 18;
+  const nativeSymbol = ((_chainInfo$substrateI2 = chainInfo.substrateInfo) === null || _chainInfo$substrateI2 === void 0 ? void 0 : _chainInfo$substrateI2.symbol) || ((_chainInfo$evmInfo2 = chainInfo.evmInfo) === null || _chainInfo$evmInfo2 === void 0 ? void 0 : _chainInfo$evmInfo2.symbol) || '';
+  const initData = {
+    address,
+    origin: 'subscan',
+    time: extrinsicItem.block_timestamp * 1000,
+    chainType,
+    from: address,
+    signature: extrinsicItem.signature,
+    fromName: undefined,
+    direction: _KoniTypes.TransactionDirection.SEND,
+    blockNumber: extrinsicItem.block_num,
+    blockHash: '',
+    chain: chainInfo.slug,
+    type: _KoniTypes.ExtrinsicType.UNKNOWN,
+    to: '',
+    toName: undefined,
+    extrinsicHash: extrinsicItem.extrinsic_hash,
+    amount: {
+      value: '0',
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    data: extrinsicItem.params,
+    fee: {
+      value: extrinsicItem.fee,
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    status: extrinsicItem.success ? _KoniTypes.ExtrinsicStatus.SUCCESS : _KoniTypes.ExtrinsicStatus.FAIL,
+    nonce: extrinsicItem.nonce
+  };
+  try {
+    return _subscanExtrinsicParserHelper.subscanExtrinsicParserMap[extrinsicParserKey](initData);
+  } catch (e) {
+    console.log('parseSubscanExtrinsicData error:', e, initData);
+    return null;
+  }
+}
+function parseSubscanTransferData(address, transferItem, chainInfo) {
+  var _chainInfo$substrateI3, _chainInfo$evmInfo3, _chainInfo$substrateI4, _chainInfo$evmInfo4;
+  const chainType = chainInfo.substrateInfo ? _KoniTypes.ChainType.SUBSTRATE : _KoniTypes.ChainType.EVM;
+  const nativeDecimals = ((_chainInfo$substrateI3 = chainInfo.substrateInfo) === null || _chainInfo$substrateI3 === void 0 ? void 0 : _chainInfo$substrateI3.decimals) || ((_chainInfo$evmInfo3 = chainInfo.evmInfo) === null || _chainInfo$evmInfo3 === void 0 ? void 0 : _chainInfo$evmInfo3.decimals) || 18;
+  const nativeSymbol = ((_chainInfo$substrateI4 = chainInfo.substrateInfo) === null || _chainInfo$substrateI4 === void 0 ? void 0 : _chainInfo$substrateI4.symbol) || ((_chainInfo$evmInfo4 = chainInfo.evmInfo) === null || _chainInfo$evmInfo4 === void 0 ? void 0 : _chainInfo$evmInfo4.symbol) || '';
+  const from = autoFormatAddress(transferItem.from);
+  const to = autoFormatAddress(transferItem.to);
+  return {
+    address,
+    origin: 'subscan',
+    time: transferItem.block_timestamp * 1000,
+    chainType,
+    from,
+    fromName: transferItem.from_account_display.display,
+    direction: address === from ? _KoniTypes.TransactionDirection.SEND : _KoniTypes.TransactionDirection.RECEIVED,
+    blockNumber: transferItem.block_num,
+    blockHash: '',
+    chain: chainInfo.slug,
+    type: _KoniTypes.ExtrinsicType.TRANSFER_BALANCE,
+    to,
+    toName: transferItem.to_account_display.display,
+    extrinsicHash: transferItem.hash,
+    amount: {
+      value: transferItem.amount,
+      decimals: 0,
+      symbol: transferItem.asset_symbol
+    },
+    fee: {
+      value: transferItem.fee,
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    status: transferItem.success ? _KoniTypes.ExtrinsicStatus.SUCCESS : _KoniTypes.ExtrinsicStatus.FAIL,
+    nonce: transferItem.nonce
+  };
+}

package/cjs/services/storage-service/DatabaseService.js

@@ -13,10 +13,12 @@ var _ChainStakingMetadata = _interopRequireDefault(require("@subwallet/extension
 var _MantaPay = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/MantaPay"));
 var _NominatorMetadata = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata"));
 var _utils = require("@subwallet/extension-base/utils");
+var _dexieExportImport = require("dexie-export-import");
 var _util = require("@polkadot/util");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+const EXPORT_EXCLUDE_TABLES = ['metadata'];
 class DatabaseService {
   // TODO: might remove this
 
@@ -287,5 +289,43 @@ class DatabaseService {
   upsertCampaign(campaign) {
     return this.stores.campaign.upsertCampaign(campaign);
   }
+  async exportDB() {
+    const blob = await (0, _dexieExportImport.exportDB)(this._db, {
+      filter: (table, value, key) => {
+        if (EXPORT_EXCLUDE_TABLES.indexOf(table) >= 0) {
+          return false;
+        }
+        return true;
+      }
+    });
+    return await blob.text();
+  }
+  async importDB(data) {
+    try {
+      const blob = new Blob([data], {
+        type: 'application/json'
+      });
+      await this._db.import(blob, {
+        overwriteValues: true,
+        acceptMissingTables: true,
+        acceptVersionDiff: true
+      });
+      return true;
+    } catch (e) {
+      this.logger.error(e);
+      return false;
+    }
+  }
+  async checkImportMetadata(data) {
+    try {
+      const blob = new Blob([data], {
+        type: 'application/json'
+      });
+      return await (0, _dexieExportImport.peakImportFile)(blob);
+    } catch (e) {
+      this.logger.error(e);
+      return null;
+    }
+  }
 }
 exports.default = DatabaseService;