@subwallet/extension-base 1.1.21-3 → 1.1.23-0

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);
@@ -206,9 +206,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 +1498,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 +1507,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 +1583,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.21-3'
+  version: '1.1.23-0'
 };
 exports.packageInfo = packageInfo;

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

@@ -19,7 +19,8 @@ exports.API_MAX_RETRY = API_MAX_RETRY;
 const _API_OPTIONS_CHAIN_GROUP = {
   acala: ['acala', 'karura', 'origintrail', 'kintsugi'],
   turing: ['turingStaging', 'turing'],
-  avail: ['kate']
+  avail: ['kate'],
+  goldberg: ['goldberg_testnet']
 };
 exports._API_OPTIONS_CHAIN_GROUP = _API_OPTIONS_CHAIN_GROUP;
 const _PREDEFINED_SINGLE_MODES = {
@@ -40,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 = {
@@ -209,8 +212,9 @@ const _TRANSFER_CHAIN_GROUP = {
   statemine: ['statemint', 'statemine', 'darwinia2', 'astar', 'shiden', 'shibuya', 'parallel'],
   riochain: ['riochain'],
   sora_substrate: ['sora_substrate'],
-  avail: ['kate'],
-  pendulum: ['pendulum', 'amplitude', 'amplitude_test']
+  avail: ['kate', 'goldberg_testnet'],
+  pendulum: ['pendulum', 'amplitude', 'amplitude_test'],
+  centrifuge: ['centrifuge']
 };
 exports._TRANSFER_CHAIN_GROUP = _TRANSFER_CHAIN_GROUP;
 const _BALANCE_PARSING_CHAIN_GROUP = {

package/cjs/services/chain-service/handler/SubstrateApi.js

@@ -1,5 +1,6 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -19,6 +20,7 @@ var _api3 = require("@polkadot/apps-config/api");
 var _create = require("@polkadot/types/create");
 var _util = require("@polkadot/util");
 var _defaults = require("@polkadot/util-crypto/address/defaults");
+var _goldberg = _interopRequireDefault(require("./chain-spec/goldberg"));
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -91,6 +93,13 @@ class SubstrateApi {
         types: _availJsSdk.spec.types,
         signedExtensions: _availJsSdk.spec.signedExtensions
       });
+    } else if (_constants._API_OPTIONS_CHAIN_GROUP.goldberg.includes(this.chainSlug)) {
+      api = new _api2.ApiPromise({
+        provider,
+        rpc: _goldberg.default.rpc,
+        types: _goldberg.default.types,
+        signedExtensions: _goldberg.default.signedExtensions
+      });
     } else {
       api = new _api2.ApiPromise(apiOption);
     }

package/cjs/services/chain-service/handler/chain-spec/goldberg.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const chainSpec = {
+  types: {
+    AppId: 'Compact<u32>',
+    DataLookupIndexItem: {
+      appId: 'AppId',
+      start: 'Compact<u32>'
+    },
+    DataLookup: {
+      size: 'Compact<u32>',
+      index: 'Vec<DataLookupIndexItem>'
+    },
+    KateCommitment: {
+      rows: 'Compact<u16>',
+      cols: 'Compact<u16>',
+      commitment: 'Vec<u8>',
+      dataRoot: 'H256'
+    },
+    V1HeaderExtension: {
+      appLookup: 'DataLookup',
+      commitment: 'KateCommitment'
+    },
+    HeaderExtension: {
+      _enum: {
+        V1: 'V1HeaderExtension'
+      }
+    },
+    DaHeader: {
+      parentHash: 'Hash',
+      number: 'Compact<BlockNumber>',
+      stateRoot: 'Hash',
+      extrinsicsRoot: 'Hash',
+      digest: 'Digest',
+      extension: 'HeaderExtension'
+    },
+    Header: 'DaHeader',
+    CheckAppIdExtra: {
+      appId: 'AppId'
+    },
+    CheckAppIdTypes: {},
+    CheckAppId: {
+      extra: 'CheckAppIdExtra',
+      types: 'CheckAppIdTypes'
+    },
+    BlockLength: {
+      max: 'PerDispatchClass',
+      cols: 'Compact<u32>',
+      rows: 'Compact<u32>',
+      chunkSize: 'Compact<u32>'
+    },
+    PerDispatchClass: {
+      normal: 'u32',
+      operational: 'u32',
+      mandatory: 'u32'
+    },
+    DataProof: {
+      root: 'H256',
+      proof: 'Vec<H256>',
+      numberOfLeaves: 'Compact<u32>',
+      leaf_index: 'Compact<u32>',
+      leaf: 'H256'
+    },
+    Cell: {
+      row: 'u32',
+      col: 'u32'
+    }
+  },
+  rpc: {
+    kate: {
+      blockLength: {
+        description: 'Get Block Length',
+        params: [{
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'BlockLength'
+      },
+      queryProof: {
+        description: 'Generate the kate proof for the given `cells`',
+        params: [{
+          name: 'cells',
+          type: 'Vec<Cell>'
+        }, {
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'Vec<u8>'
+      },
+      queryDataProof: {
+        description: 'Generate the data proof for the given `index`',
+        params: [{
+          name: 'data_index',
+          type: 'u32'
+        }, {
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'DataProof'
+      }
+    }
+  },
+  signedExtensions: {
+    CheckAppId: {
+      extrinsic: {
+        appId: 'AppId'
+      },
+      payload: {}
+    }
+  }
+};
+var _default = chainSpec;
+exports.default = _default;

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
+  };
+}