@subwallet/extension-base 1.1.43-0 → 1.1.44-0

package/koni/api/nft/ordinal_nft/constants.d.ts

@@ -1,5 +1,3 @@
-export declare const GET_EVENT_LIST_API = "https://{{chain}}.api.subscan.io/api/v2/scan/events";
-export declare const GET_EXTRINSIC_PARAMS_API = "https://{{chain}}.api.subscan.io/api/scan/extrinsic/params";
 export declare const BASE_FETCH_ORDINAL_EVENT_DATA: {
     event_id: string;
     module: string;

package/koni/api/nft/ordinal_nft/constants.js

@@ -1,8 +1,6 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export const GET_EVENT_LIST_API = 'https://{{chain}}.api.subscan.io/api/v2/scan/events';
-export const GET_EXTRINSIC_PARAMS_API = 'https://{{chain}}.api.subscan.io/api/scan/extrinsic/params';
 export const BASE_FETCH_ORDINAL_EVENT_DATA = {
   event_id: 'Remarked',
   module: 'system',

package/koni/api/nft/ordinal_nft/index.d.ts

@@ -1,4 +1,4 @@
-import { BaseNftApi, HandleNftParams } from '@subwallet/extension-base/koni/api/nft/nft';
+import { BaseNftApi, HandleNftParams } from '../nft';
 export default class OrdinalNftApi extends BaseNftApi {
     subscanChain: string;
     constructor(addresses: string[], chain: string, subscanChain: string);

package/koni/api/nft/ordinal_nft/index.js

@@ -2,9 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ORDINAL_COLLECTION } from '@subwallet/extension-base/constants';
-import { BaseNftApi } from '@subwallet/extension-base/koni/api/nft/nft';
-import { fetchExtrinsicParams, fetchRemarkEvent } from '@subwallet/extension-base/koni/api/nft/ordinal_nft/utils';
 import { state } from '@subwallet/extension-base/koni/background/handlers';
+import { BaseNftApi } from "../nft.js";
 const parseParamData = (param, event, chain, address) => {
   const ordinalData = JSON.parse(param.value);
   if ('p' in ordinalData) {
@@ -46,14 +45,10 @@ export default class OrdinalNftApi extends BaseNftApi {
     this.subscanChain = subscanChain;
   }
   async handleNft(address, handleNftParams) {
-    const events = await state.subscanService.addRequest(async () => {
-      return await fetchRemarkEvent(this.subscanChain, address);
-    });
+    const events = await state.subscanService.getAccountRemarkEvents(this.subscanChain, address);
     if (events && events.length) {
       const extrinsicIds = events.map(data => data.extrinsic_index);
-      const extrinsicParams = await state.subscanService.addRequest(async () => {
-        return await fetchExtrinsicParams(this.subscanChain, extrinsicIds);
-      });
+      const extrinsicParams = await state.subscanService.getExtrinsicParams(this.subscanChain, extrinsicIds);
       const items = [];
       for (const data of extrinsicParams) {
         const {

package/koni/api/nft/transfer.d.ts

@@ -2,7 +2,7 @@ import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/
 export declare function isRecipientSelf(currentAddress: string, recipientAddress: string): boolean;
 export declare function acalaGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
 export declare function rmrkGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
-export declare function uniqueGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
+export declare function uniqueGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null>;
 export declare function statemineGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
 export declare function statemintGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
-export declare function getNftTransferExtrinsic(networkKey: string, substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
+export declare function getNftTransferExtrinsic(networkKey: string, substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null>;

package/koni/api/nft/transfer.js

@@ -29,13 +29,24 @@ export function rmrkGetExtrinsic(substrateApi, senderAddress, recipientAddress,
     return null;
   }
 }
-export function uniqueGetExtrinsic(substrateApi, senderAddress, recipientAddress, params) {
+export async function uniqueGetExtrinsic(substrateApi, senderAddress, recipientAddress, params) {
   try {
     const itemId = params.itemId;
     const collectionId = params.collectionId;
-    return substrateApi.api.tx.unique.transfer({
-      Substrate: recipientAddress
-    }, collectionId, itemId, 1);
+
+    // @ts-ignore
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    const collectionInfo = (await substrateApi.api.rpc.unique.collectionById(collectionId)).toHuman();
+    const isTransfersEnabled = collectionInfo.limits.transfersEnabled;
+
+    // isTransfersEnabled equal to null mean that it's set as default (enable transfer)
+    if (isTransfersEnabled || isTransfersEnabled === null) {
+      return substrateApi.api.tx.unique.transfer({
+        Substrate: recipientAddress
+      }, collectionId, itemId, 1);
+    } else {
+      return null;
+    }
   } catch (e) {
     console.error(e);
     return null;
@@ -61,7 +72,7 @@ export function statemintGetExtrinsic(substrateApi, senderAddress, recipientAddr
     return null;
   }
 }
-export function getNftTransferExtrinsic(networkKey, substrateApi, senderAddress, recipientAddress, params) {
+export async function getNftTransferExtrinsic(networkKey, substrateApi, senderAddress, recipientAddress, params) {
   switch (networkKey) {
     case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.acala:
       return acalaGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
@@ -69,13 +80,12 @@ export function getNftTransferExtrinsic(networkKey, substrateApi, senderAddress,
       return acalaGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
     case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.kusama:
       return rmrkGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
-    // temporary prevent send nfts on Unique network-based chains
-    // case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.uniqueNft:
-    //   return uniqueGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
-    // case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.quartz:
-    //   return uniqueGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
-    // case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.opal:
-    //   return uniqueGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.uniqueNft:
+      return await uniqueGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.quartz:
+      return await uniqueGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.opal:
+      return await uniqueGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
     case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.statemine:
       return statemineGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
     case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.statemint:

package/koni/api/nft/unique_network_nft/index.js

@@ -18,18 +18,19 @@ export class UniqueNftApi extends BaseNftApi {
     const attRecord = nft.attributes;
     if (attRecord) {
       for (const item in attRecord) {
-        if (attRecord[item].name._.toLowerCase() === 'traits') {
-          const traits = [];
-          const traitValues = attRecord[item].value;
-          for (const trait in traitValues) {
-            traits.push(traitValues[trait]._);
+        const attName = attRecord[item].name._;
+        const attInfo = attRecord[item].value;
+        if (Array.isArray(attInfo)) {
+          const attList = [];
+          for (const trait of attInfo) {
+            attList.push(trait._);
           }
-          propertiesMap.traits = {
-            value: traits
+          propertiesMap[attName] = {
+            value: attList
           };
         } else {
-          propertiesMap[attRecord[item].name._] = {
-            value: attRecord[item].value._
+          propertiesMap[attName] = {
+            value: attInfo._
           };
         }
       }

package/koni/background/handlers/Extension.js

@@ -2005,7 +2005,7 @@ export default class KoniExtension {
     const isPSP34 = params === null || params === void 0 ? void 0 : params.isPsp34;
     const networkKey = params === null || params === void 0 ? void 0 : params.networkKey;
     const apiProps = this.#koniState.getSubstrateApi(networkKey);
-    const extrinsic = !isPSP34 ? getNftTransferExtrinsic(networkKey, apiProps, senderAddress, recipientAddress, params || {}) : await getPSP34TransferExtrinsic(networkKey, apiProps, senderAddress, recipientAddress, params || {});
+    const extrinsic = !isPSP34 ? await getNftTransferExtrinsic(networkKey, apiProps, senderAddress, recipientAddress, params || {}) : await getPSP34TransferExtrinsic(networkKey, apiProps, senderAddress, recipientAddress, params || {});
 
     // this.addContact(recipientAddress);
 

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.1.43-0",
+  "version": "1.1.44-0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -234,11 +234,6 @@
       "require": "./cjs/koni/api/nft/ordinal_nft/constants.js",
       "default": "./koni/api/nft/ordinal_nft/constants.js"
     },
-    "./koni/api/nft/ordinal_nft/utils": {
-      "types": "./koni/api/nft/ordinal_nft/utils.d.ts",
-      "require": "./cjs/koni/api/nft/ordinal_nft/utils.js",
-      "default": "./koni/api/nft/ordinal_nft/utils.js"
-    },
     "./koni/api/nft/quartz_nft": {
       "types": "./koni/api/nft/quartz_nft/index.d.ts",
       "require": "./cjs/koni/api/nft/quartz_nft/index.js",
@@ -1030,6 +1025,11 @@
       "require": "./cjs/services/migration-service/scripts/MigrateTransactionHistory.js",
       "default": "./services/migration-service/scripts/MigrateTransactionHistory.js"
     },
+    "./services/migration-service/scripts/MigrateTransactionHistoryBySymbol": {
+      "types": "./services/migration-service/scripts/MigrateTransactionHistoryBySymbol.d.ts",
+      "require": "./cjs/services/migration-service/scripts/MigrateTransactionHistoryBySymbol.js",
+      "default": "./services/migration-service/scripts/MigrateTransactionHistoryBySymbol.js"
+    },
     "./services/migration-service/scripts/MigrateWalletReference": {
       "types": "./services/migration-service/scripts/MigrateWalletReference.d.ts",
       "require": "./cjs/services/migration-service/scripts/MigrateWalletReference.js",
@@ -1791,11 +1791,11 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.7.26",
-    "@subwallet/chain-list": "0.2.43",
-    "@subwallet/extension-base": "^1.1.43-0",
-    "@subwallet/extension-chains": "^1.1.43-0",
-    "@subwallet/extension-dapp": "^1.1.43-0",
-    "@subwallet/extension-inject": "^1.1.43-0",
+    "@subwallet/chain-list": "0.2.45",
+    "@subwallet/extension-base": "^1.1.44-0",
+    "@subwallet/extension-chains": "^1.1.44-0",
+    "@subwallet/extension-dapp": "^1.1.44-0",
+    "@subwallet/extension-inject": "^1.1.44-0",
     "@subwallet/keyring": "^0.1.3",
     "@subwallet/ui-keyring": "^0.1.3",
     "@walletconnect/sign-client": "^2.8.4",

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.1.43-0'
+  version: '1.1.44-0'
 };

package/services/chain-service/constants.d.ts

@@ -56,7 +56,6 @@ export declare const _TRANSFER_CHAIN_GROUP: {
     acala: string[];
     kintsugi: string[];
     genshiro: string[];
-    crab: string[];
     bitcountry: string[];
     statemine: string[];
     riochain: string[];

package/services/chain-service/constants.js

@@ -29,7 +29,7 @@ export const _BALANCE_CHAIN_GROUP = {
   genshiro: ['genshiro_testnet', 'genshiro'],
   equilibrium_parachain: ['equilibrium_parachain'],
   bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main', 'pendulum', 'amplitude', 'continuum_network'],
-  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel', 'calamari', 'manta_network', 'rococo_assethub', 'liberlandTest', 'liberland', 'dentnet'],
+  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel', 'calamari', 'manta_network', 'rococo_assethub', 'liberlandTest', 'liberland', 'dentnet', 'pangolin'],
   kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'],
   // perhaps there are some runtime updates
   centrifuge: ['centrifuge'],
@@ -201,7 +201,7 @@ export const _TRANSFER_CHAIN_GROUP = {
   acala: ['karura', 'acala', 'acala_testnet'],
   kintsugi: ['kintsugi', 'kintsugi_test', 'interlay', 'mangatax_para'],
   genshiro: ['genshiro_testnet', 'genshiro', 'equilibrium_parachain'],
-  crab: ['crab', 'pangolin'],
+  // crab: ['crab', 'pangolin'],
   bitcountry: ['pioneer', 'bitcountry', 'bifrost', 'bifrost_dot'],
   statemine: ['statemint', 'statemine', 'darwinia2', 'astar', 'shiden', 'shibuya', 'parallel', 'liberland', 'liberlandTest', 'dentnet'],
   riochain: ['riochain'],
@@ -209,7 +209,7 @@ export const _TRANSFER_CHAIN_GROUP = {
   avail: ['kate', 'goldberg_testnet'],
   pendulum: ['pendulum', 'amplitude', 'amplitude_test', 'hydradx_main'],
   centrifuge: ['centrifuge'],
-  disable_transfer: ['invarch']
+  disable_transfer: ['invarch', 'crab', 'pangolin']
 };
 export const _BALANCE_PARSING_CHAIN_GROUP = {
   bobabeam: ['bobabeam', 'bobabase']
@@ -237,7 +237,8 @@ export const _XCM_TYPE = {
 export const _DEFAULT_ACTIVE_CHAINS = [..._DEFAULT_CHAINS, 'vara_network'];
 export const EVM_PASS_CONNECT_STATUS = {
   arbitrum_one: ['*'],
-  okxTest: ['*']
+  okxTest: ['*'],
+  astarZkEvm: ['*']
 };
 export const EVM_REFORMAT_DECIMALS = {
   acala: ['acala_evm', 'karura_evm']

package/services/migration-service/scripts/MigrateTransactionHistoryBySymbol.d.ts

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

package/services/migration-service/scripts/MigrateTransactionHistoryBySymbol.js

@@ -0,0 +1,54 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateTransactionHistoryBySymbol extends BaseMigrationJob {
+  async run() {
+    const state = this.state;
+    try {
+      const changeSlugsMap = {
+        'ethereum-ERC20-WFTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870': 'ethereum-ERC20-FTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870',
+        'moonbeam-ERC20-CSG-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F': 'moonbeam-ERC20-CGS-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F',
+        'astar-LOCAL-aUSD': 'astar-LOCAL-aSEED',
+        'astarEvm-ERC20-aUSD-0xfFFFFfFF00000000000000010000000000000001': 'astarEvm-ERC20-aSEED-0xfFFFFfFF00000000000000010000000000000001',
+        'moonriver-LOCAL-xcaUSD': 'moonriver-LOCAL-xcaSeed',
+        'moonriver-LOCAL-xckBTC': 'moonriver-LOCAL-xcKBTC',
+        'bifrost-LOCAL-aUSD': 'bifrost-LOCAL-KUSD',
+        'calamari-LOCAL-aUSD': 'calamari-LOCAL-AUSD',
+        'shiden-LOCAL-aUSD': 'shiden-LOCAL-aSEED',
+        'shidenEvm-ERC20-aUSD-0xfFFfFFfF00000000000000010000000000000000': 'shidenEvm-ERC20-aSEED-0xfFFfFFfF00000000000000010000000000000000',
+        'ethereum_goerli-NATIVE-GoerliETH': 'ethereum_goerli-NATIVE-ETH',
+        'binance_test-NATIVE-BNB': 'binance_test-NATIVE-tBNB',
+        'pangolin-LOCAL-CKTON': 'pangolin-LOCAL-PKTON',
+        'zeta_test-NATIVE-aZETA': 'zeta_test-NATIVE-ZETA',
+        'origintrail-NATIVE-OTP': 'origintrail-NATIVE-NEURO',
+        'moonbeam-LOCAL-xciBTC': 'moonbeam-LOCAL-xcIBTC'
+      };
+      const allTxs = [];
+      await Promise.all(Object.entries(changeSlugsMap).map(async ([oldSlug, newSlug], i) => {
+        const oldSlugSplit = oldSlug.split('-');
+        const oldChainSlug = oldSlugSplit[0];
+        const oldSymbolSlug = oldSlugSplit[2];
+        const newSlugSplit = newSlug.split('-');
+        const newSymbolSlug = newSlugSplit[2];
+        const filterTransactions = await state.dbService.stores.transaction.table.where({
+          chain: oldChainSlug
+        }).and(tx => {
+          var _tx$amount;
+          return ((_tx$amount = tx.amount) === null || _tx$amount === void 0 ? void 0 : _tx$amount.symbol) === oldSymbolSlug;
+        }).toArray();
+        if (filterTransactions.length > 0) {
+          for (const transaction of filterTransactions) {
+            if (transaction.amount && transaction.amount.symbol === oldSymbolSlug) {
+              transaction.amount.symbol = newSymbolSlug;
+            }
+          }
+        }
+        allTxs.push(...filterTransactions);
+      }));
+      await state.dbService.stores.transaction.table.bulkPut(allTxs);
+    } catch (e) {
+      this.logger.error(e);
+    }
+  }
+}

package/services/migration-service/scripts/databases/MigrateAssetSetting.js

@@ -5,27 +5,29 @@ import BaseMigrationJob from '@subwallet/extension-base/services/migration-servi
 export default class MigrateAssetSetting extends BaseMigrationJob {
   async run() {
     try {
-      const oldSlugs = ['ethereum-ERC20-WFTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870', 'moonbeam-ERC20-CSG-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F', 'astar-LOCAL-aUSD', 'astarEvm-ERC20-aUSD-0xfFFFFfFF00000000000000010000000000000001',
-      //
-      'moonriver-LOCAL-xcaUSD',
-      //
-      'moonriver-LOCAL-xckBTC', 'bifrost-LOCAL-aUSD', 'calamari-LOCAL-AUSD', 'shiden-LOCAL-aUSD', 'shidenEvm-ERC20-aUSD-0xfFFfFFfF00000000000000010000000000000000',
-      //
-      'ethereum_goerli-NATIVE-GoerliETH', 'binance_test-NATIVE-BNB',
-      //
-      'pangolin-LOCAL-CKTON',
-      //
-      'zeta_test-NATIVE-aZETA' //
-      ];
-
-      const newSlugs = ['ethereum-ERC20-FTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870', 'moonbeam-ERC20-CGS-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F', 'astar-LOCAL-aSEED', 'astarEvm-ERC20-aSEED-0xfFFFFfFF00000000000000010000000000000001', 'moonriver-LOCAL-xcaSeed', 'moonriver-LOCAL-xcKBTC', 'bifrost-LOCAL-KUSD', 'calamari-LOCAL-AUSD', 'shiden-LOCAL-aSEED', 'shidenEvm-ERC20-aSEED-0xfFFfFFfF00000000000000010000000000000000', 'ethereum_goerli-NATIVE-ETH', 'binance_test-NATIVE-tBNB', 'pangolin-LOCAL-PKTON', 'zeta_test-NATIVE-ZETA'];
+      const changeSlugsMap = {
+        'ethereum-ERC20-WFTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870': 'ethereum-ERC20-FTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870',
+        'moonbeam-ERC20-CSG-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F': 'moonbeam-ERC20-CGS-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F',
+        'astar-LOCAL-aUSD': 'astar-LOCAL-aSEED',
+        'astarEvm-ERC20-aUSD-0xfFFFFfFF00000000000000010000000000000001': 'astarEvm-ERC20-aSEED-0xfFFFFfFF00000000000000010000000000000001',
+        'moonriver-LOCAL-xcaUSD': 'moonriver-LOCAL-xcaSeed',
+        'moonriver-LOCAL-xckBTC': 'moonriver-LOCAL-xcKBTC',
+        'bifrost-LOCAL-aUSD': 'bifrost-LOCAL-KUSD',
+        'calamari-LOCAL-aUSD': 'calamari-LOCAL-AUSD',
+        'shiden-LOCAL-aUSD': 'shiden-LOCAL-aSEED',
+        'shidenEvm-ERC20-aUSD-0xfFFfFFfF00000000000000010000000000000000': 'shidenEvm-ERC20-aSEED-0xfFFfFFfF00000000000000010000000000000000',
+        'ethereum_goerli-NATIVE-GoerliETH': 'ethereum_goerli-NATIVE-ETH',
+        'binance_test-NATIVE-BNB': 'binance_test-NATIVE-tBNB',
+        'pangolin-LOCAL-CKTON': 'pangolin-LOCAL-PKTON',
+        'zeta_test-NATIVE-aZETA': 'zeta_test-NATIVE-ZETA',
+        'origintrail-NATIVE-OTP': 'origintrail-NATIVE-NEURO',
+        'moonbeam-LOCAL-xciBTC': 'moonbeam-LOCAL-xcIBTC'
+      };
       const assetSetting = await this.state.chainService.getAssetSettings();
       const migratedAssetSetting = {};
-      for (let i = 0; i < oldSlugs.length; i++) {
-        const slug = oldSlugs[i];
-        if (Object.keys(assetSetting).includes(slug)) {
-          const isVisible = assetSetting[slug].visible;
-          const newSlug = newSlugs[i];
+      for (const [oldSlug, newSlug] of Object.entries(changeSlugsMap)) {
+        if (Object.keys(assetSetting).includes(oldSlug)) {
+          const isVisible = assetSetting[oldSlug].visible;
           migratedAssetSetting[newSlug] = {
             visible: isVisible
           };

package/services/migration-service/scripts/index.js

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import DeleteEarningData from '@subwallet/extension-base/services/migration-service/scripts/DeleteEarningData';
-// import MigrateAssetSetting from './databases/MigrateAssetSetting';
+import MigrateTransactionHistoryBySymbol from '@subwallet/extension-base/services/migration-service/scripts/MigrateTransactionHistoryBySymbol';
+import MigrateAssetSetting from "./databases/MigrateAssetSetting.js";
 import MigrateEarningVersion from "./databases/MigrateEarningVersion.js";
 import MigrateEthProvider from "./providers/MigrateEthProvider.js";
 import MigratePioneerProvider from "./providers/MigratePioneerProvider.js";
@@ -44,7 +45,9 @@ export default {
   '1.1.24-01': MigrateProvidersV1M1P24,
   '1.1.26-01': MigratePolygonUSDCProvider,
   '1.1.28-01': MigrateEarningVersion,
-  '1.1.41-01': DeleteChainStaking
-  // '1.1.41-02': MigrateAssetSetting
+  '1.1.41-01': DeleteChainStaking,
+  '1.1.44-01': MigrateAssetSetting,
+  '1.1.44-02': MigrateTransactionHistoryBySymbol
+  // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
 };

package/services/subscan-service/index.d.ts

@@ -1,9 +1,13 @@
 import { CrowdloanContributionsResponse, ExtrinsicItem, ExtrinsicsListResponse, IMultiChainBalance, RequestBlockRange, RewardHistoryListResponse, SubscanRequest, TransferItem, TransfersListResponse } from '@subwallet/extension-base/services/subscan-service/types';
+import { SubscanEventBaseItemData, SubscanExtrinsicParam } from '@subwallet/extension-base/types';
 export declare class SubscanService {
     private subscanChainMap;
+    private callRate;
     private limitRate;
     private intervalCheck;
     private maxRetry;
+    private rollbackRateTime;
+    private timeoutRollbackRate;
     private requestMap;
     private nextId;
     private isRunning;
@@ -13,9 +17,10 @@ export declare class SubscanService {
         intervalCheck?: number;
         maxRetry?: number;
     });
+    private reduceLimitRate;
     private getApiUrl;
     private postRequest;
-    addRequest<T>(run: SubscanRequest<T>['run']): Promise<T>;
+    addRequest<T>(run: SubscanRequest<T>['run'], ordinal: number): Promise<T>;
     private process;
     checkSupportedSubscanChain(chain: string): boolean;
     setSubscanChainMap(subscanChainMap: Record<string, string>): void;
@@ -32,4 +37,6 @@ export declare class SubscanService {
         record: number;
     }): Promise<Record<string, TransferItem[]>>;
     getRewardHistoryList(chain: string, address: string, page?: number): Promise<RewardHistoryListResponse>;
+    getAccountRemarkEvents(chain: string, address: string): Promise<SubscanEventBaseItemData[]>;
+    getExtrinsicParams(chain: string, extrinsicIndexes: string[], ordinal?: number): Promise<SubscanExtrinsicParam[]>;
 }

package/services/subscan-service/index.js

@@ -2,13 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import { BASE_FETCH_ORDINAL_EVENT_DATA } from '@subwallet/extension-base/koni/api/nft/ordinal_nft/constants';
 import { wait } from '@subwallet/extension-base/utils';
 import fetch from 'cross-fetch';
 const QUERY_ROW = 100;
 export class SubscanService {
-  limitRate = 2; // limit per interval check
+  callRate = 2; // limit per interval check
+  limitRate = 2; // max rate per interval check
   intervalCheck = 1000; // interval check in ms
   maxRetry = 9; // interval check in ms
+  rollbackRateTime = 30 * 1000; // rollback rate time in ms
+  timeoutRollbackRate = undefined;
   requestMap = {};
   nextId = 0;
   isRunning = false;
@@ -17,10 +21,18 @@ export class SubscanService {
   }
   constructor(subscanChainMap, options) {
     this.subscanChainMap = subscanChainMap;
+    this.callRate = (options === null || options === void 0 ? void 0 : options.limitRate) || this.callRate;
     this.limitRate = (options === null || options === void 0 ? void 0 : options.limitRate) || this.limitRate;
     this.intervalCheck = (options === null || options === void 0 ? void 0 : options.intervalCheck) || this.intervalCheck;
     this.maxRetry = (options === null || options === void 0 ? void 0 : options.maxRetry) || this.maxRetry;
   }
+  reduceLimitRate() {
+    clearTimeout(this.timeoutRollbackRate);
+    this.callRate = Math.ceil(this.limitRate / 2);
+    this.timeoutRollbackRate = setTimeout(() => {
+      this.callRate = this.limitRate;
+    }, this.rollbackRateTime);
+  }
   getApiUrl(chain, path) {
     const subscanChain = this.subscanChainMap[chain];
     if (!subscanChain) {
@@ -37,13 +49,14 @@ export class SubscanService {
       body: JSON.stringify(body)
     });
   }
-  addRequest(run) {
+  addRequest(run, ordinal) {
     const newId = this.getId();
     return new Promise((resolve, reject) => {
       this.requestMap[newId] = {
         id: newId,
         status: 'pending',
         retry: -1,
+        ordinal,
         run,
         resolve,
         reject
@@ -65,7 +78,7 @@ export class SubscanService {
       }
 
       // Get first this.limit requests base on id
-      const requests = remainingRequests.filter(request => request.status !== 'running').sort((a, b) => a.id - b.id).slice(0, this.limitRate);
+      const requests = remainingRequests.filter(request => request.status !== 'running').sort((a, b) => a.id - b.id).sort((a, b) => a.ordinal - b.ordinal).slice(0, this.callRate);
 
       // Start requests
       requests.forEach(request => {
@@ -73,12 +86,20 @@ export class SubscanService {
         request.run().then(rs => {
           request.resolve(rs);
         }).catch(e => {
-          if (request.retry < maxRetry) {
-            request.status = 'pending';
-            request.retry++;
+          const error = JSON.parse(e.message);
+
+          // Limit rate
+          if (error.code === 20008) {
+            if (request.retry < maxRetry) {
+              request.status = 'pending';
+              request.retry++;
+              this.reduceLimitRate();
+            } else {
+              // Reject request
+              request.reject(new SWError('MAX_RETRY', String(e)));
+            }
           } else {
-            // Reject request
-            request.reject(new SWError('MAX_RETRY', String(e)));
+            request.reject(new SWError('UNKNOWN', String(e)));
           }
         });
       });
@@ -102,7 +123,7 @@ export class SubscanService {
       }
       const jsonData = await rs.json();
       return jsonData.data;
-    });
+    }, 1);
   }
   getCrowdloanContributions(relayChain, address, page = 0) {
     return this.addRequest(async () => {
@@ -117,7 +138,7 @@ export class SubscanService {
       }
       const jsonData = await rs.json();
       return jsonData.data;
-    });
+    }, 2);
   }
   getExtrinsicsList(chain, address, page = 0, blockRange) {
     const _blockRange = (() => {
@@ -127,7 +148,7 @@ export class SubscanService {
       return `${blockRange.from || 0}-${blockRange.to}`;
     })();
     return this.addRequest(async () => {
-      const rs = await this.postRequest(this.getApiUrl(chain, 'api/scan/extrinsics'), {
+      const rs = await this.postRequest(this.getApiUrl(chain, 'api/v2/scan/extrinsics'), {
         page,
         row: QUERY_ROW,
         address,
@@ -138,7 +159,7 @@ export class SubscanService {
       }
       const jsonData = await rs.json();
       return jsonData.data;
-    });
+    }, 0);
   }
   async fetchAllPossibleExtrinsicItems(chain, address, cbAfterEachRequest, limit = {
     page: 10,
@@ -159,11 +180,26 @@ export class SubscanService {
       if (res.count > maxCount) {
         maxCount = res.count;
       }
-      cbAfterEachRequest === null || cbAfterEachRequest === void 0 ? void 0 : cbAfterEachRequest(res.extrinsics);
-      res.extrinsics.forEach(item => {
+      const extrinsics = res.extrinsics;
+      const extrinsicIndexes = extrinsics.map(item => item.extrinsic_index);
+      const extrinsicParams = await this.getExtrinsicParams(chain, extrinsicIndexes, 0);
+      for (const data of extrinsicParams) {
+        const {
+          extrinsic_index: extrinsicIndex,
+          params
+        } = data;
+        const extrinsic = extrinsics.find(item => item.extrinsic_index === extrinsicIndex);
+        if (extrinsic) {
+          extrinsic.params = JSON.stringify(params);
+        }
+      }
+
+      // Call callback after each request, for parse data
+      cbAfterEachRequest === null || cbAfterEachRequest === void 0 ? void 0 : cbAfterEachRequest(extrinsics);
+      for (const item of extrinsics) {
         resultMap[item.extrinsic_hash] = item;
-      });
-      currentCount += res.extrinsics.length;
+      }
+      currentCount += extrinsics.length;
       if (page > limit.page || currentCount > limit.record) {
         return;
       }
@@ -193,7 +229,7 @@ export class SubscanService {
       }
       const jsonData = await rs.json();
       return jsonData.data;
-    });
+    }, 0);
   }
   async fetchAllPossibleTransferItems(chain, address, direction, cbAfterEachRequest, limit = {
     page: 10,
@@ -250,6 +286,31 @@ export class SubscanService {
       }
       const jsonData = await rs.json();
       return jsonData.data;
-    });
+    }, 2);
+  }
+  getAccountRemarkEvents(chain, address) {
+    return this.addRequest(async () => {
+      const rs = await this.postRequest(this.getApiUrl(chain, 'api/v2/scan/events'), {
+        ...BASE_FETCH_ORDINAL_EVENT_DATA,
+        address
+      });
+      if (rs.status !== 200) {
+        throw new SWError('SubscanService.getAccountRemarkEvents', await rs.text());
+      }
+      const jsonData = await rs.json();
+      return jsonData.data.events;
+    }, 3);
+  }
+  getExtrinsicParams(chain, extrinsicIndexes, ordinal = 3) {
+    return this.addRequest(async () => {
+      const rs = await this.postRequest(this.getApiUrl(chain, 'api/scan/extrinsic/params'), {
+        extrinsic_index: extrinsicIndexes
+      });
+      if (rs.status !== 200) {
+        throw new SWError('SubscanService.getExtrinsicParams', await rs.text());
+      }
+      const jsonData = await rs.json();
+      return jsonData.data;
+    }, ordinal);
   }
 }